@uipath/solution-tool 1.200.0-preview.109 → 1.201.0-preview.115

package/dist/{packager-tool-gnmkvkz3.js → packager-tool-9x8dbxbn.js}

@@ -6,11 +6,11 @@ import {
   listDeploymentsAsync,
   listPackagesAsync,
   uninstallDeploymentAsync
-} from "./packager-tool-br2aa2fh.js";
+} from "./packager-tool-n49qbf8m.js";
 import {
   SolutionInitError,
   solutionInitAsync
-} from "./packager-tool-kfzzznjr.js";
+} from "./packager-tool-85x8cje1.js";
 import {
   GOVERNANCE_OPTION_INSTRUCTIONS,
   PackCommandService,
@@ -18,28 +18,35 @@ import {
   applyAuthConnection,
   createSolutionPackager,
   ensurePackagerTools,
+  packSolutionAsync,
   readSolutionFileAsUint8Array,
   resolveSdkLogLevel,
   validateGovernanceOptions
-} from "./packager-tool-7efxm815.js";
+} from "./packager-tool-y35nbbkm.js";
 import {
   publishSolutionAsync
-} from "./packager-tool-rdxaysxe.js";
+} from "./packager-tool-c84z58bt.js";
 import {
   Configuration,
   Configuration1 as Configuration2,
   DeploymentActivationStatus,
   DeploymentOperationStatus,
   DeploymentsApi,
+  PackagesApi,
   PipelinesApi,
   SearchApi,
   bundleSolution,
+  feedResolutionFailureInstructions,
+  feedScopeInitOverride,
+  folderKeyInitOverride,
   importSolution,
   listSelectablePublishLocations,
+  resolveFeedScope,
   resolvePersonalWorkspace,
+  searchPackageVersions,
   solutionExistsOnStudioWeb,
   uploadOrOverwriteSolution
-} from "./packager-tool-gkwmyc48.js";
+} from "./packager-tool-arbagkf2.js";
 import {
   Tokens,
   applyEntryPointEnhancementAsync,
@@ -60,7 +67,7 @@ import {
   syncAndLog,
   syncResourcesFromBindings,
   writeSolutionFile
-} from "./packager-tool-37g19zk3.js";
+} from "./packager-tool-ngh4qwjv.js";
 import {
   ToolResult
 } from "./packager-tool-vpr77gre.js";
@@ -93,12 +100,13 @@ import {
   resolveSolutionDir,
   toPortableRelativePath,
   trackShipSucceeded,
+  unsupportedSolutionProjectType,
   updateUipxSolutionId,
   withCompleter
-} from "./packager-tool-y4wacqkp.js";
+} from "./packager-tool-r9n45rjm.js";
 import {
   getFileSystem
-} from "./packager-tool-q90kqh83.js";
+} from "./packager-tool-7eva0peq.js";
 import {
   unzipSync
 } from "./packager-tool-129wn232.js";
@@ -106,7 +114,7 @@ import {
 var package_default = {
   name: "@uipath/solution-tool",
   license: "MIT",
-  version: "1.200.0-preview.109",
+  version: "1.201.0-preview.115",
   description: "Create, pack, publish, and deploy UiPath Automation Solutions.",
   repository: {
     type: "git",
@@ -169,6 +177,7 @@ var package_default = {
     "@uipath/packager-tool-connector": "workspace:*",
     "@uipath/packager-tool-webapp": "workspace:*",
     "@uipath/pipelines-sdk": "workspace:*",
+    "@uipath/project-executor": "workspace:*",
     "@uipath/resource-builder-sdk": "^2025.11.0-alpha4202-3459",
     "@uipath/resource-builder-tool": "2025.11.0-alpha4535-3530",
     "@uipath/solution-packager": "workspace:*",
@@ -1458,11 +1467,6 @@ var fail = (reason, message, instructions, exitCode = 1) => ({
   exitCode
 });
 var AUTH_INSTRUCTIONS = "Run 'uip login' to refresh credentials, then retry. If the deployment is in a different tenant, switch with 'uip login tenant set <tenant>'.";
-function folderScope(folderKey) {
-  return async ({ init }) => ({
-    headers: { ...init.headers, "X-UIPATH-FolderKey": folderKey }
-  });
-}
 async function upgradeDeploymentAsync(deploymentKey, options = {}) {
   const [authError, auth] = await catchError(getSolutionAuthContext({
     tenant: options.tenant,
@@ -1487,7 +1491,7 @@ async function upgradeDeploymentAsync(deploymentKey, options = {}) {
     if (pwError || !pw) {
       return fail("personal_workspace_failed", pwError?.message ?? "Personal Workspace could not be resolved.", "Ensure your user has a Personal Workspace, then retry.");
     }
-    feedScope = folderScope(pw.key);
+    feedScope = folderKeyInitOverride(pw.key);
   }
   const [getError, deployment] = await catchError(deploymentsApi.deploymentsGetByKey({ deploymentKey }, feedScope));
   if (getError || !deployment) {
@@ -2057,8 +2061,100 @@ var SOLUTION_PACKAGES_DELETE_EXAMPLES = [
     }
   }
 ];
+var SEARCH_PAGE_SIZE = 50;
+function scopeName(scope) {
+  if (scope.kind === "tenant") {
+    return "the tenant feed";
+  }
+  if (scope.name) {
+    return `'${scope.name}'`;
+  }
+  return scope.kind === "personal" ? "the Personal Workspace feed" : "the selected feed";
+}
+function packageDeleteFailureInstructions(scope, packageName) {
+  const base = "Check that the package name and version are correct and that you have permission to delete it.";
+  if (scope.kind === "personal") {
+    return `List workspace packages with: uip solution packages list --personal-workspace --name ${packageName}.`;
+  }
+  if (scope.kind === "folder") {
+    return `List packages in that feed with: uip solution packages list --feed <name-or-key> --name ${packageName}.`;
+  }
+  if (isPreviewBuild()) {
+    return `${base} If the package was published to a Personal Workspace or folder feed, add --personal-workspace or --feed.`;
+  }
+  return `${base} If the package was published to a Personal Workspace, add --personal-workspace.`;
+}
+async function resolvePackageVersionKey(auth, scope, packageName, packageVersion) {
+  const config = new Configuration2({
+    basePath: auth.basePath,
+    accessToken: auth.accessToken
+  });
+  const searchApi = new SearchApi(config);
+  const pkg = await findPackage(searchApi, scope, packageName);
+  if (pkg.latestVersion === packageVersion) {
+    return pkg.packageVersionKey;
+  }
+  for (let skip = 0;; ) {
+    const page = await searchPackageVersions({ basePath: auth.basePath, accessToken: auth.accessToken }, pkg.key, {
+      searchTerm: packageVersion,
+      take: SEARCH_PAGE_SIZE,
+      skip,
+      excludeInvalidPackages: true
+    }, scope.folderKey);
+    const match = page.values.find((version) => version.version === packageVersion);
+    if (match) {
+      return match.key;
+    }
+    if (page.values.length < SEARCH_PAGE_SIZE) {
+      throw new Error(`Package version '${packageName}@${packageVersion}' was not found in ${scopeName(scope)}.`);
+    }
+    skip += page.values.length;
+  }
+}
+async function findPackage(searchApi, scope, packageName) {
+  for (let skip = 0;; ) {
+    const packages = await searchApi.searchSearchPackages({
+      searchFilter: {
+        searchTerm: packageName,
+        take: SEARCH_PAGE_SIZE,
+        skip
+      }
+    }, feedScopeInitOverride(scope));
+    const values = packages.values ?? [];
+    const match = values.find((pkg) => pkg.name === packageName);
+    if (match) {
+      return match;
+    }
+    if (values.length < SEARCH_PAGE_SIZE) {
+      throw new Error(`Package '${packageName}' was not found in ${scopeName(scope)}.`);
+    }
+    skip += values.length;
+  }
+}
+async function deleteTenantPackageVersion(auth, packageName, packageVersion) {
+  const api = new PipelinesApi(new Configuration({
+    basePath: auth.basePath,
+    accessToken: auth.accessToken
+  }));
+  await api.pipelinesPackageDelete({
+    packageName,
+    packageVersion
+  });
+}
+async function deleteScopedPackageVersion(auth, scope, packageName, packageVersion) {
+  const packageVersionKey = await resolvePackageVersionKey(auth, scope, packageName, packageVersion);
+  const packagesApi = new PackagesApi(new Configuration2({
+    basePath: auth.basePath,
+    accessToken: auth.accessToken
+  }));
+  await packagesApi.packagesDeleteVersion({ packageVersionKey }, feedScopeInitOverride(scope));
+}
 var registerPackagesDeleteCommand = (program) => {
-  program.command("delete").description("Delete a specific version of a solution package. " + "Use 'solution packages list' to find available package names and versions.").argument("<package-name>", "The name of the package").argument("<package-version>", "The version to delete (e.g. 1.0.0)").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).option("-y, --yes", "Confirm this irreversible operation (required; the CLI never prompts)").examples(SOLUTION_PACKAGES_DELETE_EXAMPLES).trackedAction(processContext, async (packageName, packageVersion, options) => {
+  const command = program.command("delete").description("Delete a specific version of a solution package. " + "Use 'solution packages list' to find available package names and versions.").argument("<package-name>", "The name of the package").argument("<package-version>", "The version to delete (e.g. 1.0.0)").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).option("-y, --yes", "Confirm this irreversible operation (required; the CLI never prompts)").option("--personal-workspace", "Delete the package version from the current user's Personal Workspace feed.");
+  if (isPreviewBuild()) {
+    command.addOption(new Option("--feed <name-or-key>", "Delete the package version from this feed (name or folder key, from 'solution feeds list'). Mutually exclusive with --personal-workspace.").conflicts("personalWorkspace"));
+  }
+  command.examples(SOLUTION_PACKAGES_DELETE_EXAMPLES).trackedAction(processContext, async (packageName, packageVersion, options) => {
     if (!requireConfirmation(options, `delete package '${packageName}@${packageVersion}'`)) {
       return;
     }
@@ -2075,20 +2171,28 @@ var registerPackagesDeleteCommand = (program) => {
       processContext.exit(1);
       return;
     }
-    const api = new PipelinesApi(new Configuration({
-      basePath: auth.basePath,
-      accessToken: auth.accessToken
-    }));
-    const [deleteError] = await catchError(api.pipelinesPackageDelete({
-      packageName,
-      packageVersion
+    const [scopeError, scope] = await catchError(resolveFeedScope({
+      personalWorkspace: options.personalWorkspace,
+      feed: options.feed,
+      tenant: options.tenant,
+      loginValidity: options.loginValidity
     }));
+    if (scopeError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: scopeError.message,
+        Instructions: feedResolutionFailureInstructions(options)
+      });
+      processContext.exit(1);
+      return;
+    }
+    const [deleteError] = await catchError(scope.kind === "tenant" ? deleteTenantPackageVersion(auth, packageName, packageVersion) : deleteScopedPackageVersion(auth, scope, packageName, packageVersion));
     if (deleteError) {
       const { message } = await extractErrorDetails(deleteError);
       OutputFormatter.error({
         Result: RESULTS.Failure,
         Message: message,
-        Instructions: "Check that the package name and version are correct and that you have permission to delete it."
+        Instructions: packageDeleteFailureInstructions(scope, packageName)
       });
       processContext.exit(1);
       return;
@@ -2310,9 +2414,9 @@ var SOLUTION_PACKAGES_LIST_EXAMPLES = [
   }
 ];
 var registerPackagesListCommand = (program) => {
-  const command = 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'.").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("-l, --limit <number>", "Number of packages to return", parseLimit, DEFAULT_PAGE_SIZE).option("--offset <number>", "Number of packages to skip", parseOffset, 0).option("--sort-by <column>", "Column to sort by (default: publishDate)", "publishDate").option("--sort-order <direction>", "Sort direction: Ascending or Descending (default: Descending)", "Descending").option("--name <pattern>", "Filter packages by name (server-side substring match)").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10);
+  const command = 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'.").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("-l, --limit <number>", "Number of packages to return", parseLimit, DEFAULT_PAGE_SIZE).option("--offset <number>", "Number of packages to skip", parseOffset, 0).option("--sort-by <column>", "Column to sort by (default: publishDate)", "publishDate").option("--sort-order <direction>", "Sort direction: Ascending or Descending (default: Descending)", "Descending").option("--name <pattern>", "Filter packages by name (server-side substring match)").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).option("--personal-workspace", "Only list packages in the current user's Personal Workspace feed.");
   if (isPreviewBuild()) {
-    command.addOption(new Option("--feed <name-or-key>", "Only list packages in this feed (name or folder key, from 'solution feeds list'). Mutually exclusive with --personal-workspace.").conflicts("personalWorkspace")).option("--personal-workspace", "Only list packages in the current user's Personal Workspace feed.");
+    command.addOption(new Option("--feed <name-or-key>", "Only list packages in this feed (name or folder key, from 'solution feeds list'). Mutually exclusive with --personal-workspace.").conflicts("personalWorkspace"));
   }
   command.examples(SOLUTION_PACKAGES_LIST_EXAMPLES).trackedAction(processContext, async (options) => {
     const result = await listPackagesAsync({
@@ -2376,6 +2480,21 @@ async function resolveAppV2SubType(projectDir) {
   return manifest?.config?.isActionApp === true ? "CodedAction" : "Coded";
 }
 
+// src/commands/project-command-utils.ts
+function rejectUnsupportedProjectType(projectType, failureMessage) {
+  const reason = unsupportedSolutionProjectType(projectType);
+  if (!reason) {
+    return false;
+  }
+  OutputFormatter.error({
+    Result: RESULTS.Failure,
+    Message: failureMessage,
+    Instructions: reason
+  });
+  processContext.exit(1);
+  return true;
+}
+
 // src/commands/project-add.ts
 var PROJECT_ADD_EXAMPLES = [
   {
@@ -2464,6 +2583,9 @@ var registerProjectAddCommand = (project) => {
       processContext.exit(1);
       return;
     }
+    if (rejectUnsupportedProjectType(parsedProject.projectType, "Failed to add project to solution")) {
+      return;
+    }
     const [readSolutionError, parsedSolution] = await readSolutionFile(resolvedSolutionFile);
     if (readSolutionError) {
       OutputFormatter.error({
@@ -2607,6 +2729,9 @@ var registerProjectImportCommand = (project) => {
       processContext.exit(1);
       return;
     }
+    if (rejectUnsupportedProjectType(parsedProject.projectType, "Failed to import project into solution")) {
+      return;
+    }
     const [solutionFileError, resolvedSolutionFile] = await resolveSolutionFilePath(solutionFile, cwd);
     if (solutionFileError) {
       OutputFormatter.error({
@@ -3017,7 +3142,8 @@ var registerProjectRemoveCommand = (project) => {
       return;
     }
     const projects = solution.Projects ?? [];
-    if (projects.length <= 1) {
+    const removingUnsupportedType = unsupportedSolutionProjectType(projects[projectIndex].Type) !== null;
+    if (projects.length <= 1 && !removingUnsupportedType) {
       OutputFormatter.error({
         Result: RESULTS.Failure,
         Message: "Failed to remove project from solution",
@@ -3245,7 +3371,7 @@ function formatSyncErrors(errors) {
 }
 
 // src/commands/project.ts
-var PROJECTS_DESCRIPTION = "Manage projects within a UiPath solution (.uipx). Add, import, or remove automation projects (workflows, test cases, libraries) from the solution manifest.";
+var PROJECTS_DESCRIPTION = "Manage projects within a UiPath solution (.uipx). Add, import, list, or remove the automation projects registered in the solution manifest — RPA processes, tests, agents, Maestro flows, case and BPMN projects, coded apps, functions, API workflows, and other buildable project types. A library is not a project: publish it on its own, then attach it with 'uip solution resources add --source remote --kind Library --name <library-name>'.";
 var PROJECT_ALIAS_DESCRIPTION = "Deprecated alias of 'uip solution projects'. Use 'uip solution projects' instead.";
 var wireProjectSubcommands = (group) => {
   registerProjectAddCommand(group);
@@ -4802,6 +4928,525 @@ var registerRestoreCommand = (program) => {
     }, processContext);
   });
 };
+// ../executor/project-executor/src/models/run-status.ts
+var TERMINAL_RUN_STATUSES = [
+  "Succeeded" /* Succeeded */,
+  "Faulted" /* Faulted */,
+  "Cancelled" /* Cancelled */
+];
+function isTerminalRunStatus(status) {
+  return TERMINAL_RUN_STATUSES.includes(status);
+}
+
+// ../executor/project-executor/src/models/run-result.ts
+class RunResult {
+  status;
+  errorCode;
+  rawStatus;
+  message;
+  jobKey;
+  instanceId;
+  runId;
+  traceId;
+  steps;
+  output;
+  url;
+  details;
+  constructor(status, errorCode = "None" /* None */, message) {
+    this.status = status;
+    this.errorCode = errorCode;
+    this.message = message;
+  }
+  get isSuccess() {
+    return this.status === "Succeeded" /* Succeeded */ && this.errorCode === "None" /* None */;
+  }
+  get isTerminal() {
+    return isTerminalRunStatus(this.status);
+  }
+  static succeeded(init = {}) {
+    return Object.assign(new RunResult("Succeeded" /* Succeeded */, "None" /* None */), init);
+  }
+  static failed(errorCode, message, init = {}) {
+    return Object.assign(new RunResult("Faulted" /* Faulted */, errorCode, message), init);
+  }
+}
+// ../executor/project-executor/src/services/executor-tool-import.ts
+async function importExecutorToolModule(specifier) {
+  try {
+    return { module: await import(specifier) };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+}
+
+// ../executor/project-executor/src/services/executor-tool-module.ts
+var EXECUTOR_FACTORY_EXPORT = "createExecutorFactory";
+function isExecutorFactoryModule(module) {
+  return typeof module === "object" && module !== null && typeof module[EXECUTOR_FACTORY_EXPORT] === "function";
+}
+
+// ../executor/project-executor/src/services/executors-factory-repository.ts
+class ExecutorsFactoryRepository {
+  factoryMap = new Map;
+  onConflict;
+  constructor(onConflict) {
+    this.onConflict = onConflict ?? ((message) => console.warn(message));
+  }
+  registerProjectExecutorFactory(factory) {
+    for (const projectType of factory.supportedTypes) {
+      const existing = this.factoryMap.get(projectType);
+      if (existing) {
+        if (existing.constructor?.name !== factory.constructor?.name) {
+          this.onConflict(`Executor factory conflict for project type '${projectType}': ` + `'${existing.constructor?.name}' already registered, ` + `ignoring '${factory.constructor?.name}'.`);
+        }
+        continue;
+      }
+      this.factoryMap.set(projectType, factory);
+    }
+  }
+  canHandleProject(projectType) {
+    return this.factoryMap.has(projectType);
+  }
+  getProjectExecutorFactory(projectType) {
+    const factory = this.factoryMap.get(projectType);
+    if (!factory) {
+      throw new Error(`No executor is registered for project type '${projectType}'. ` + `Registered types: ${this.registeredTypes.join(", ") || "none"}.`);
+    }
+    return factory;
+  }
+  get registeredTypes() {
+    return [...this.factoryMap.keys()];
+  }
+  reset() {
+    this.factoryMap.clear();
+  }
+}
+var REGISTRY_KEY = Symbol.for("@uipath/project-executor/executorsFactoryRepository");
+var _global = globalThis;
+if (!_global[REGISTRY_KEY]) {
+  _global[REGISTRY_KEY] = new ExecutorsFactoryRepository;
+}
+var executorsFactoryRepository = _global[REGISTRY_KEY];
+
+// ../executor/project-executor/src/services/executor-factory-provider.ts
+var PROVIDER_KEY = Symbol.for("@uipath/project-executor/executorFactoryProvider");
+var _global2 = globalThis;
+function registerExecutorFactoryFromModule(module, source) {
+  if (!isExecutorFactoryModule(module)) {
+    throw new Error(`${source} does not export ${EXECUTOR_FACTORY_EXPORT}().`);
+  }
+  const factory = module.createExecutorFactory();
+  executorsFactoryRepository.registerProjectExecutorFactory(factory);
+  return factory;
+}
+async function ensureExecutorFactory(verb, packageName) {
+  const provider = _global2[PROVIDER_KEY];
+  if (provider) {
+    await provider(verb);
+    return;
+  }
+  if (!packageName) {
+    throw new Error(`Running this project type needs the executor factory for '${verb}', and no package provides it.`);
+  }
+  const specifier = `${packageName}/executor-tool`;
+  const { module, error } = await importExecutorToolModule(specifier);
+  if (error) {
+    throw new Error(`Running this project type needs '${packageName}'. Install it.`, { cause: error });
+  }
+  registerExecutorFactoryFromModule(module, specifier);
+}
+// ../executor/project-executor/src/services/executor-logger.ts
+var noopExecutorLogger = {
+  info: () => {},
+  warn: () => {},
+  error: () => {}
+};
+// ../executor/project-executor/src/services/project-runner.ts
+class ProjectRunner {
+  fileSystem;
+  logger;
+  registry;
+  constructor(deps) {
+    this.fileSystem = deps.fileSystem;
+    this.logger = deps.logger ?? noopExecutorLogger;
+    this.registry = deps.registry ?? executorsFactoryRepository;
+  }
+  canRun(projectType) {
+    return this.registry.canHandleProject(projectType);
+  }
+  get runnableTypes() {
+    return this.registry.registeredTypes;
+  }
+  async runAsync(options, cancellationToken) {
+    const { projectType, name } = options.project;
+    if (!this.canRun(projectType)) {
+      const known = this.runnableTypes.join(", ") || "none";
+      return RunResult.failed("UnsupportedProjectType" /* UnsupportedProjectType */, `No executor is registered for project type '${projectType}' ` + `(project '${name}'). Runnable types: ${known}.`);
+    }
+    let executor;
+    try {
+      const factory = this.registry.getProjectExecutorFactory(projectType);
+      executor = await factory.createAsync(this.logger, this.fileSystem);
+      this.logger.info(`Running ${name} (${projectType}) on ${options.target}.`);
+      return await executor.runAsync(options, cancellationToken);
+    } catch (error) {
+      return RunResult.failed("Unknown" /* Unknown */, messageOf(error));
+    } finally {
+      try {
+        await executor?.dispose();
+      } catch (error) {
+        this.logger.warn(`Failed to dispose the ${projectType} executor: ${messageOf(error)}`);
+      }
+    }
+  }
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+// src/services/executor-tool-resolver.ts
+var PROJECT_TYPE_TO_TOOL = new Map([
+  ["Process", "rpa"],
+  ["Tests", "rpa"],
+  ["WebApp", "rpa"],
+  ["Agent", "agent"]
+]);
+var TOOL_TO_PACKAGE = new Map([
+  ["rpa", "@uipath/rpa-tool"],
+  ["agent", "@uipath/agent-tool"]
+]);
+function hasExecutorToolFor(projectType) {
+  return PROJECT_TYPE_TO_TOOL.has(projectType);
+}
+async function ensureExecutorTools(projectTypes) {
+  const neededTools = new Set;
+  for (const type of projectTypes) {
+    if (executorsFactoryRepository.canHandleProject(type))
+      continue;
+    const toolVerb = PROJECT_TYPE_TO_TOOL.get(type);
+    if (toolVerb) {
+      neededTools.add(toolVerb);
+    } else {
+      logger.warn(`No CLI tool provides an executor for project type '${type}'. Run may fail.`);
+    }
+  }
+  for (const toolVerb of neededTools) {
+    logger.info(`Loading executor factory for '${toolVerb}' to run project types...`);
+    await ensureExecutorFactory(toolVerb, TOOL_TO_PACKAGE.get(toolVerb));
+  }
+}
+function projectDirOf(fs, declaredPath) {
+  const dir = fs.path.dirname(declaredPath);
+  return dir && dir !== "." ? dir : "";
+}
+async function readSolutionProjects(solutionDir, fs) {
+  const entries = await fs.readdir(solutionDir);
+  const uipxFile = entries.find((f) => f.endsWith(".uipx"));
+  if (!uipxFile) {
+    throw new Error(`No .uipx solution file found in '${solutionDir}'. ` + `Pass a solution directory or run 'uip solution init' first.`);
+  }
+  const content = await fs.readFile(fs.path.join(solutionDir, uipxFile));
+  if (!content) {
+    throw new Error(`Solution file '${uipxFile}' is empty.`);
+  }
+  const json = typeof content === "string" ? content : new TextDecoder().decode(content);
+  const [parseError, solution] = catchError(() => JSON.parse(json));
+  if (parseError) {
+    throw new Error(`Failed to parse ${uipxFile}: ${parseError.message}`);
+  }
+  return (solution.Projects ?? []).map((p) => {
+    const relativePath = projectDirOf(fs, p.ProjectRelativePath ?? "");
+    return {
+      name: p.Name || fs.path.basename(relativePath || solutionDir) || "",
+      projectType: p.Type ?? "",
+      relativePath
+    };
+  });
+}
+
+// src/services/provision-debug-service.ts
+function nextDebugVersion() {
+  return `1.0.${Math.floor(Date.now() / 1000)}`;
+}
+async function defaultGetSolutionBuilder(solutionDir) {
+  const services = await createResourceBuilderServices();
+  return services.getSolutionBuilder(solutionDir, true);
+}
+async function provisionSolutionForDebugAsync(options, deps = {}) {
+  const listLocations = deps.listLocations ?? listSelectablePublishLocations;
+  const pack = deps.pack ?? packSolutionAsync;
+  const publish = deps.publish ?? publishSolutionAsync;
+  const getBuilder = deps.getSolutionBuilder ?? defaultGetSolutionBuilder;
+  const newSessionId = deps.newSessionId ?? (() => crypto.randomUUID());
+  const authOptions = {
+    tenant: options.tenant,
+    loginValidity: options.loginValidity
+  };
+  logger.info("Resolving the personal workspace to deploy into...");
+  const [locationsError, locations] = await catchError(listLocations(authOptions));
+  if (locationsError) {
+    return fail2(`Could not resolve a personal workspace to deploy into: ${locationsError.message}`);
+  }
+  const personal = locations.find((l) => l.isMyPersonalWorkspace);
+  if (!personal) {
+    return fail2("This account has no personal workspace, so there is nowhere to deploy the solution for a debug run. " + "Ask an administrator to enable a personal workspace, or run with --no-provision-resources — " + "the run then starts without a deployment, and cross-project calls will not resolve.");
+  }
+  const version = options.version ?? nextDebugVersion();
+  const fs = getFileSystem();
+  const outputPath = fs.path.join(fs.env.tmpdir(), "uip-solution-run", newSessionId());
+  logger.info("Packing the solution...");
+  const [packError, packed] = await catchError(pack(options.solutionDir, {
+    output: outputPath,
+    name: options.solutionName,
+    version,
+    loginValidity: options.loginValidity
+  }));
+  if (packError) {
+    return fail2(`Packing the solution failed: ${packError.message}`);
+  }
+  if (!packed.ok) {
+    return fail2(`Packing the solution failed: ${packed.message}`);
+  }
+  const packagePath = packed.packages?.[0];
+  if (!packagePath) {
+    return fail2("Packing the solution produced no package.");
+  }
+  logger.info("Uploading the solution to the personal workspace...");
+  const [publishError, published] = await catchError(publish(packagePath, {
+    ...authOptions,
+    personalWorkspace: true,
+    packageVersion: version
+  }));
+  if (publishError) {
+    return fail2(`Uploading the solution failed: ${publishError.message}`);
+  }
+  if (!published.ok) {
+    return fail2(`Uploading the solution failed: ${published.message}`);
+  }
+  if (!published.packageVersionKey) {
+    return fail2("The solution was uploaded but the feed did not report a package version, so it cannot be provisioned. Retry the run.");
+  }
+  logger.info("Provisioning the solution's resources for the run...");
+  const [builderError, builder] = await catchError(getBuilder(options.solutionDir));
+  if (builderError) {
+    return fail2(`Could not read the solution: ${builderError.message}`);
+  }
+  const [debugError, debug] = await catchError(builder.debugProjectAsync(personal.key, options.solutionName, newSessionId(), published.packageVersionKey, true));
+  await builder.disposeAsync().catch(() => {});
+  if (debugError) {
+    return fail2(`Provisioning the solution failed: ${debugError.message}`);
+  }
+  if (debug.complete === false) {
+    return fail2("The solution is still being provisioned in the cloud, and this command cannot yet wait for it to finish. " + "Give it a moment and run again — the second run reuses the completed provisioning.");
+  }
+  const folderPath = debug.folderFullyQualifiedName;
+  logger.info(folderPath ? `Solution provisioned into ${folderPath}.` : "Solution provisioned.");
+  return {
+    ok: true,
+    folderPath,
+    packageVersionKey: published.packageVersionKey
+  };
+}
+function fail2(message) {
+  return { ok: false, message };
+}
+
+// src/services/run-service.ts
+async function runSolutionAsync(options, deps, cancellationToken) {
+  const { fileSystem } = deps;
+  const solutionDir = fileSystem.path.resolve(options.solutionPath);
+  const [readError, projects] = await catchError(readSolutionProjects(solutionDir, fileSystem));
+  if (readError) {
+    return RunResult.failed("InvalidInput" /* InvalidInput */, readError.message);
+  }
+  const runnable = projects.filter((p) => hasExecutorToolFor(p.projectType));
+  if (runnable.length === 0) {
+    const seen = projects.map((p) => `${p.name} (${p.projectType})`).join(", ") || "none";
+    return RunResult.failed("UnsupportedProjectType" /* UnsupportedProjectType */, `No project in this solution can be run. Projects: ${seen}.`);
+  }
+  const [selectionError, selected] = selectProject(runnable, options.projectName);
+  if (selectionError) {
+    return RunResult.failed("InvalidInput" /* InvalidInput */, selectionError);
+  }
+  const provision = deps.provisionForDebug ?? provisionSolutionForDebugAsync;
+  const shouldProvision = options.provisionResources ?? projects.length > 1;
+  const [executorOutcome, provisionOutcome] = await Promise.allSettled([
+    ensureExecutorTools([selected.projectType]),
+    shouldProvision ? provision({
+      solutionDir,
+      solutionName: fileSystem.path.basename(solutionDir),
+      tenant: options.tenant,
+      loginValidity: options.loginValidity
+    }) : Promise.resolve(undefined)
+  ]);
+  if (executorOutcome.status === "rejected") {
+    return RunResult.failed("PrepareFailed" /* PrepareFailed */, `Could not load the executor for project type '${selected.projectType}': ${describeError(executorOutcome.reason)}`);
+  }
+  if (provisionOutcome.status === "rejected") {
+    return RunResult.failed("PrepareFailed" /* PrepareFailed */, `Could not deploy the solution before the run: ${describeError(provisionOutcome.reason)}`);
+  }
+  let folderPath = options.folderPath;
+  const provisioned = provisionOutcome.value;
+  if (provisioned) {
+    if (!provisioned.ok) {
+      return RunResult.failed("PrepareFailed" /* PrepareFailed */, provisioned.message ?? "Could not deploy the solution before the run.");
+    }
+    folderPath = provisioned.folderPath;
+  }
+  const projectPath = fileSystem.path.resolve(solutionDir, selected.relativePath);
+  logger.debug(`Running '${selected.name}' (${selected.projectType}) from ${projectPath}` + `${options.entryPoint ? ` with entry point ${options.entryPoint}` : " with its default entry point"}`);
+  const connection = await resolveConnection(folderPath, options, deps);
+  const runner = new ProjectRunner({
+    fileSystem,
+    logger: deps.logger
+  });
+  return runner.runAsync({
+    project: {
+      name: selected.name,
+      projectType: selected.projectType,
+      projectPath
+    },
+    entryPoint: options.entryPoint,
+    inputArguments: options.inputArguments,
+    target: "Local" /* Local */,
+    connection,
+    siblingProjects: projects.filter((p) => p !== selected).map((p) => ({
+      name: p.name,
+      projectType: p.projectType,
+      projectPath: fileSystem.path.resolve(solutionDir, p.relativePath)
+    })),
+    timeoutMs: options.timeoutMs
+  }, cancellationToken);
+}
+async function resolveConnection(folderPath, options, deps) {
+  const getLoginStatus = deps.getLoginStatus ?? getLoginStatusAsync;
+  const [loginError, status] = await catchError(getLoginStatus({
+    ensureTokenValidityMinutes: options.loginValidity
+  }));
+  if (loginError || status.loginStatus !== "Logged in") {
+    logger.debug(`No signed-in session for the run: ${loginError?.message ?? status.loginStatus}. ` + "A project type that needs one will say so.");
+    return {
+      folderPath,
+      baseUrl: "",
+      accessToken: "",
+      organizationId: "",
+      organizationName: ""
+    };
+  }
+  return {
+    folderPath,
+    baseUrl: status.baseUrl ?? "",
+    accessToken: status.accessToken ?? "",
+    organizationId: status.organizationId ?? "",
+    organizationName: status.organizationName ?? "",
+    tenantId: status.tenantId,
+    tenantName: status.tenantName
+  };
+}
+function describeError(reason) {
+  return reason instanceof Error ? reason.message : String(reason);
+}
+function selectProject(runnable, requested) {
+  if (requested) {
+    const match = runnable.find((p) => p.name === requested);
+    if (!match) {
+      const names = runnable.map((p) => p.name).join(", ");
+      return [
+        `Project '${requested}' is not a runnable project in this solution. Runnable projects: ${names}.`,
+        runnable[0]
+      ];
+    }
+    return [undefined, match];
+  }
+  if (runnable.length > 1) {
+    const names = runnable.map((p) => p.name).join(", ");
+    return [
+      `This solution has more than one runnable project, so one has to be named with --project-name. Runnable projects: ${names}.`,
+      runnable[0]
+    ];
+  }
+  return [undefined, runnable[0]];
+}
+
+// src/commands/run.ts
+var ERROR_CODE_BY_RUN_ERROR = {
+  ["InvalidInput" /* InvalidInput */]: "invalid_argument",
+  ["UnsupportedProjectType" /* UnsupportedProjectType */]: "invalid_argument",
+  ["Unauthorized" /* Unauthorized */]: "authentication_required",
+  ["Timeout" /* Timeout */]: "timeout"
+};
+var NEVER_STARTED = new Set([
+  "InvalidInput" /* InvalidInput */,
+  "UnsupportedProjectType" /* UnsupportedProjectType */,
+  "Unauthorized" /* Unauthorized */
+]);
+var registerRunCommand = (program) => {
+  program.command("run", { hidden: true }).description("Run a project from a UiPath solution. Currently supports RPA projects and agents.").argument("<solutionPath>", "Path to a solution directory (containing .uipx)").option("--project-name <name>", "Name of the project to run. Required only when the solution has more than one runnable project.").option("--entry-point <path>", "Entry point to execute (for RPA, a workflow such as Main.xaml). Defaults to the project's own entry point.").option("--input-arguments <json>", `Input arguments for the entry point, as a JSON object string (e.g. '{"name": "World"}').`).option("--folder-path <path>", "Orchestrator folder the run reports itself under, when the runtime needs one. Ignored when the solution is deployed, which uses the folder it deploys into.").option("--provision-resources", "Pack and deploy the solution into your personal workspace before running, even when the solution holds a single project. Done automatically for a solution with more than one project.").option("--no-provision-resources", "Run without deploying the solution first. Cross-project calls will not resolve.").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10).", Number.parseInt, 10).trackedAction(processContext, async (solutionPath, options) => {
+    const [inputError, inputArguments] = parseInputArguments(options.inputArguments);
+    if (inputError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Failed to run solution",
+        Instructions: inputError,
+        ErrorCode: "invalid_argument"
+      });
+      processContext.exit(1);
+      return;
+    }
+    const result = await runSolutionAsync({
+      solutionPath,
+      projectName: options.projectName,
+      entryPoint: options.entryPoint,
+      inputArguments,
+      folderPath: options.folderPath,
+      provisionResources: options.provisionResources,
+      loginValidity: options.loginValidity
+    }, { fileSystem: getFileSystem(), logger });
+    if (!result.isSuccess) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: result.message ?? "The run did not succeed.",
+        Instructions: NEVER_STARTED.has(result.errorCode) ? `The run did not start (${result.errorCode}).` : `Run ended with status '${result.status}' (${result.errorCode}).`,
+        ErrorCode: ERROR_CODE_BY_RUN_ERROR[result.errorCode]
+      });
+      processContext.exit(1);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "SolutionRun",
+      Data: {
+        Status: result.status,
+        EntryPoint: result.details?.entryPoint,
+        Output: result.output
+      }
+    }, { preserveDataKeys: true });
+  });
+};
+function parseInputArguments(raw) {
+  if (raw === undefined)
+    return [undefined, undefined];
+  const [parseError, parsed] = catchError(() => JSON.parse(raw));
+  if (parseError) {
+    return [
+      `--input-arguments is not valid JSON: ${parseError.message}. Provide a JSON object (e.g. '{"name": "World"}').`,
+      undefined
+    ];
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return [
+      `--input-arguments must be a JSON object keyed by argument name (e.g. '{"name": "World"}'), not ${describeJson(parsed)}.`,
+      undefined
+    ];
+  }
+  return [undefined, parsed];
+}
+function describeJson(value) {
+  if (value === null)
+    return "null";
+  return Array.isArray(value) ? "an array" : `a ${typeof value}`;
+}
 
 // src/commands/upload.ts
 var SOLUTION_UPLOAD_EXAMPLES = [
@@ -5004,6 +5649,7 @@ var registerCommands = async (program) => {
   registerPackCommand(program);
   registerCleanupCommand(program);
   registerRestoreCommand(program);
+  registerRunCommand(program);
   registerDownloadCommand(program);
   registerNewCommand(program);
   registerProjectCommand(program);
@@ -5017,4 +5663,4 @@ var registerCommands = async (program) => {
 
 export { metadata, registerCommands };
 
-//# debugId=7B39B2BFA5F3331B64756E2164756E21
+//# debugId=88BBF99B737F82D864756E2164756E21