@uipath/solution-tool 1.204.0-preview.254 → 1.205.0-preview.256

package/dist/packager-tool-act5r386.js

@@ -0,0 +1,239 @@
+// src/utils/deployment-errors.ts
+function coerceWorkflowErrorMessages(raw) {
+  if (Array.isArray(raw)) {
+    return raw.map(coerceWorkflowErrorMessage).filter((error) => error !== undefined);
+  }
+  const coerced = coerceWorkflowErrorMessage(raw);
+  if (coerced) {
+    return [coerced];
+  }
+  return [];
+}
+function coerceWorkflowErrorMessage(raw) {
+  if (raw === null || raw === undefined) {
+    return;
+  }
+  if (typeof raw === "string") {
+    const trimmed = raw.trim();
+    return trimmed ? { errorMessage: trimmed } : undefined;
+  }
+  if (!isRecord(raw)) {
+    return { errorMessage: String(raw) };
+  }
+  if (typeof raw.errorMessage === "string" && raw.errorMessage.trim()) {
+    return {
+      errorMessage: raw.errorMessage.trim(),
+      serviceMessage: typeof raw.serviceMessage === "string" ? raw.serviceMessage : undefined,
+      exceptionTrace: typeof raw.exceptionTrace === "string" ? raw.exceptionTrace : undefined,
+      serviceName: typeof raw.serviceName === "string" ? raw.serviceName : undefined
+    };
+  }
+  return { errorMessage: stringifyUnexpectedWorkflowError(raw) };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function stringifyUnexpectedWorkflowError(value) {
+  try {
+    return JSON.stringify(value);
+  } catch (error) {
+    return String(error);
+  }
+}
+function formatSummaryValidationError(e) {
+  return e.errorType ? `[${e.errorType}] ${e.errorText}` : e.errorText;
+}
+function formatSummaryScheduleError(e) {
+  return e.errorCode ? `[${e.errorCode}] ${e.errorText}` : e.errorText;
+}
+function formatSummaryWorkflowError(e) {
+  const parts = [e.errorMessage];
+  const details = [];
+  if (e.serviceName) {
+    details.push(`service: ${e.serviceName}`);
+  }
+  if (e.serviceMessage) {
+    details.push(`reason: ${e.serviceMessage}`);
+  }
+  if (details.length > 0) {
+    parts.push(`(${details.join(", ")})`);
+  }
+  return parts.join(" ");
+}
+function nonEmpty(arr) {
+  return arr && arr.length > 0 ? arr : undefined;
+}
+function extractDeploymentErrors(result) {
+  const validationErrors = nonEmpty(result.validationResult?.validationErrors?.map(formatSummaryValidationError));
+  const conflictSources = [
+    ...result.validationResult?.conflictErrors ?? [],
+    ...result.conflictFixingErrors ?? []
+  ];
+  const conflictErrors = nonEmpty(conflictSources.map(formatSummaryValidationError));
+  const scheduleErrors = nonEmpty(result.deploymentScheduleErrors?.map(formatSummaryScheduleError));
+  const deploymentErrors = nonEmpty(coerceWorkflowErrorMessages(result.deploymentResult?.errorMessage).map(formatSummaryWorkflowError));
+  if (!validationErrors && !conflictErrors && !scheduleErrors && !deploymentErrors) {
+    return;
+  }
+  return {
+    ValidationErrors: validationErrors,
+    ConflictErrors: conflictErrors,
+    ScheduleErrors: scheduleErrors,
+    DeploymentErrors: deploymentErrors
+  };
+}
+function formatDeploymentErrorsAsText(summary) {
+  const lines = [];
+  if (summary.ValidationErrors) {
+    lines.push(`Validation: ${summary.ValidationErrors.join("; ")}`);
+  }
+  if (summary.ConflictErrors) {
+    lines.push(`Conflicts: ${summary.ConflictErrors.join("; ")}`);
+  }
+  if (summary.ScheduleErrors) {
+    lines.push(`Schedule: ${summary.ScheduleErrors.join("; ")}`);
+  }
+  if (summary.DeploymentErrors) {
+    lines.push(`Deployment: ${summary.DeploymentErrors.join("; ")}`);
+  }
+  return lines.join(`
+`);
+}
+function formatErrorCode(errorCode) {
+  return errorCode ? `[${errorCode}] ` : "";
+}
+function formatDetailedValidationError(error) {
+  const resource = [error.kind, error.name].filter(Boolean).join(" ");
+  const prefix = resource ? `${resource}: ` : "";
+  return `${formatErrorCode(error.errorCode)}${prefix}${error.errorText}`;
+}
+function formatDetailedConflictError(error) {
+  const actions = error.conflictFixingActions?.length ? ` (fix: ${error.conflictFixingActions.join(", ")})` : "";
+  return `${formatDetailedValidationError(error)}${actions}`;
+}
+function formatDetailedScheduleError(error) {
+  return `${formatErrorCode(error.errorCode)}${error.errorText}`;
+}
+function formatDetailedWorkflowError(error) {
+  const parts = [
+    error.serviceName && error.errorMessage ? `${error.serviceName}: ${error.errorMessage}` : error.errorMessage ?? error.serviceName,
+    error.serviceMessage,
+    error.exceptionTrace
+  ].filter(Boolean);
+  return parts.join(" | ");
+}
+function formatResourceInstallError(error) {
+  const context = [error.kind, error.type, error.name].filter(Boolean).join(" ");
+  return context ? `${context}: ${error.text}` : error.text;
+}
+function formatServiceError(service) {
+  const activation = service.activationStatus && service.activationStatus !== "None" ? `, ${service.activationStatus}` : "";
+  const state = `${service.status}${activation}`;
+  const servicePrefix = service.serviceName ? `${service.serviceName} (${state})` : state;
+  const encoded = parseServiceMessages(service.errorMessage);
+  const codeByText = new Map((encoded ?? []).map((message) => [message.text, message.errorCode]));
+  const listed = service.serviceErrorMessages ?? [];
+  const errors = [];
+  if (service.errorMessage && !encoded) {
+    errors.push(`${servicePrefix}: ${service.errorMessage}`);
+  }
+  errors.push(...listed.map((error) => `${servicePrefix}: ${formatErrorCode(codeByText.get(error.text))}${formatResourceInstallError(error)}`));
+  const listedTexts = new Set(listed.map((error) => error.text));
+  errors.push(...(encoded ?? []).filter((message) => !listedTexts.has(message.text)).map((message) => `${servicePrefix}: ${formatErrorCode(message.errorCode)}${message.text}`));
+  return errors;
+}
+function formatServiceErrors(services) {
+  return services?.flatMap(formatServiceError) ?? [];
+}
+function parseServiceMessages(raw) {
+  const trimmed = raw?.trim();
+  if (!trimmed?.startsWith("[")) {
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return;
+  }
+  if (!Array.isArray(parsed) || parsed.length === 0) {
+    return;
+  }
+  const messages = [];
+  for (const entry of parsed) {
+    if (!isRecord(entry) || typeof entry.text !== "string") {
+      return;
+    }
+    messages.push({
+      text: entry.text,
+      errorCode: typeof entry.errorCode === "string" && entry.errorCode ? entry.errorCode : undefined
+    });
+  }
+  return messages;
+}
+function formatDeploymentIdentifiers(pipelineDeploymentId, status) {
+  const identifiers = [
+    `pipelineDeploymentId=${pipelineDeploymentId}`,
+    status.deploymentKey ? `deploymentKey=${status.deploymentKey}` : "",
+    status.configurationKey ? `configurationKey=${status.configurationKey}` : "",
+    status.instanceId ? `instanceId=${status.instanceId}` : ""
+  ].filter(Boolean);
+  return `Operation: ${identifiers.join(", ")}`;
+}
+function formatDeploymentFailureDetails(pipelineDeploymentId, status) {
+  return [
+    ...formatPipelineErrors(status),
+    formatDeploymentIdentifiers(pipelineDeploymentId, status)
+  ].join(`
+`);
+}
+function formatPipelineErrors(status) {
+  const errorParts = [];
+  const validationErrors = status.validationResult?.validationErrors;
+  if (validationErrors?.length) {
+    errorParts.push(`Validation: ${validationErrors.map(formatDetailedValidationError).join("; ")}`);
+  }
+  const conflictErrors = status.validationResult?.conflictErrors;
+  if (conflictErrors?.length) {
+    errorParts.push(`Conflicts: ${conflictErrors.map(formatDetailedConflictError).join("; ")}`);
+  }
+  if (status.conflictFixingErrors?.length) {
+    errorParts.push(`Conflict fixing: ${status.conflictFixingErrors.map(formatDetailedValidationError).join("; ")}`);
+  }
+  if (status.deploymentScheduleErrors?.length) {
+    errorParts.push(`Schedule: ${status.deploymentScheduleErrors.map(formatDetailedScheduleError).join("; ")}`);
+  }
+  const workflowErrors = coerceWorkflowErrorMessages(status.deploymentResult?.errorMessage);
+  if (workflowErrors.length) {
+    errorParts.push(`Deployment: ${workflowErrors.map(formatDetailedWorkflowError).join("; ")}`);
+  }
+  const serviceErrors = formatServiceErrors(status.deploymentResult?.services);
+  if (serviceErrors.length) {
+    errorParts.push(`Services: ${serviceErrors.join("; ")}`);
+  }
+  return errorParts;
+}
+function hasServerErrorCode(details, code) {
+  return new RegExp(`"errorCode"\\s*:\\s*"${code}"`).test(details);
+}
+function isBareResponse(details) {
+  return !/^\s*[{[]/.test(details);
+}
+var DRAFT_VERSION_MISMATCH_CODE = "DraftDeploymentHasDifferentPackageVersion";
+var VALIDATION_CONFIRMATION_REQUIRED_CODE = "4026";
+function leavesPendingDraft(status) {
+  return status === "ValidationFailed" || status === "ConflictFixingError" || status === "DeploymentScheduleError";
+}
+function installLandedDespiteStatus(status) {
+  const record = status.deploymentResult?.status;
+  return status.status !== "DeploymentSucceeded" && (record === "SuccessfulInstall" || record === "SuccessfulActivate");
+}
+function explainPipelineStatusAfterInstall(status) {
+  const lines = formatPipelineErrors(status);
+  const errors = lines.length > 0 ? ` ${lines.join(" ")}` : "";
+  return `The deploy pipeline ended at ${status.status} although the install landed (the deployment record reports ${status.deploymentResult?.status}): the errors it attached come from the activation validation the pipeline runs after the install, not from the install.${errors}`;
+}
+
+export { coerceWorkflowErrorMessages, extractDeploymentErrors, formatDeploymentErrorsAsText, formatServiceErrors, formatDeploymentFailureDetails, hasServerErrorCode, isBareResponse, DRAFT_VERSION_MISMATCH_CODE, VALIDATION_CONFIRMATION_REQUIRED_CODE, leavesPendingDraft, installLandedDespiteStatus, explainPipelineStatusAfterInstall };
+
+//# debugId=DE311674F41DE19664756E2164756E21

package/dist/packager-tool-amhyxzz6.js

@@ -0,0 +1,125 @@
+import {
+  logger,
+  trackShipSucceeded
+} from "./packager-tool-tx834spe.js";
+import {
+  ShipDimensions,
+  catchError
+} from "./packager-tool-6ybywxxn.js";
+import {
+  getFileSystem
+} from "./packager-tool-v1f5e8t9.js";
+import {
+  unzip
+} from "./packager-tool-dfrk01gn.js";
+
+// src/services/ship-telemetry.ts
+var PROJECT_TYPE_MAP = {
+  Agent: "low_code_agent",
+  Api: "api_workflow",
+  AppV2: "coded_app",
+  CaseManagement: "case",
+  Flow: "flow",
+  Process: "rpa",
+  ProcessOrchestration: "bpmn",
+  WebApp: "coded_app",
+  processOrchestration: "bpmn"
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeShipProjectType(projectType) {
+  return PROJECT_TYPE_MAP[projectType] ?? projectType.trim().toLowerCase();
+}
+function summarizeShipProjectTypes(projectTypes) {
+  const normalized = [
+    ...new Set(projectTypes.map((projectType) => projectType.trim()).filter(Boolean).map(normalizeShipProjectType))
+  ];
+  if (normalized.length === 0) {
+    return { projectType: "unknown" };
+  }
+  if (normalized.length === 1) {
+    return { projectType: normalized[0] };
+  }
+  const sortedProjectTypes = [...normalized];
+  sortedProjectTypes.sort((left, right) => left.localeCompare(right));
+  return {
+    projectType: "mixed",
+    projectTypes: sortedProjectTypes.join(",")
+  };
+}
+function readProjectTypesFromUipx(content) {
+  const parsed = JSON.parse(content);
+  if (!isRecord(parsed) || !Array.isArray(parsed.Projects)) {
+    return [];
+  }
+  return parsed.Projects.map((project) => {
+    if (!isRecord(project)) {
+      return;
+    }
+    return typeof project.Type === "string" ? project.Type : undefined;
+  }).filter((projectType) => projectType !== undefined);
+}
+var MAX_INSPECTABLE_PACKAGE_BYTES = 256 * 1024 * 1024;
+function isProjectManifestEntry(name) {
+  return name.endsWith(".uipx");
+}
+function unzipProjectManifests(archive) {
+  return new Promise((resolve, reject) => {
+    unzip(archive, { filter: (file) => isProjectManifestEntry(file.name) }, (error, entries) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve(entries);
+    });
+  });
+}
+async function inspectSolutionPackageProjectTypes(packagePath) {
+  const fs = getFileSystem();
+  const [statError, stats] = await catchError(fs.stat(packagePath));
+  if (statError || !stats) {
+    logger.debug(`[Cli.ShipSucceeded] Could not stat solution package for project type telemetry: ${statError?.message ?? "no stats"}`);
+    return { projectType: "unknown" };
+  }
+  if (stats.size > MAX_INSPECTABLE_PACKAGE_BYTES) {
+    logger.debug(`[Cli.ShipSucceeded] Solution package is ${stats.size} bytes, over the ${MAX_INSPECTABLE_PACKAGE_BYTES}-byte inspection cap; skipping project type telemetry.`);
+    return { projectType: "unknown" };
+  }
+  const [readError, archive] = await catchError(fs.readFile(packagePath));
+  if (readError || !archive) {
+    logger.debug(`[Cli.ShipSucceeded] Could not read solution package for project type telemetry: ${readError?.message ?? "empty archive"}`);
+    return { projectType: "unknown" };
+  }
+  const [unzipError, entries] = await catchError(unzipProjectManifests(new Uint8Array(archive)));
+  if (unzipError || !entries) {
+    logger.debug(`[Cli.ShipSucceeded] Could not inspect solution package zip: ${unzipError?.message ?? "no entries"}`);
+    return { projectType: "unknown" };
+  }
+  const decoder = new TextDecoder;
+  const projectTypes = [];
+  for (const [entryName, entryBytes] of Object.entries(entries)) {
+    if (!isProjectManifestEntry(entryName)) {
+      continue;
+    }
+    const [parseError, parsedTypes] = await catchError(Promise.resolve().then(() => readProjectTypesFromUipx(decoder.decode(entryBytes))));
+    if (parseError) {
+      logger.debug(`[Cli.ShipSucceeded] Could not parse ${entryName} for project type telemetry: ${parseError.message}`);
+      continue;
+    }
+    projectTypes.push(...parsedTypes);
+  }
+  return summarizeShipProjectTypes(projectTypes);
+}
+function trackSolutionShipSucceeded(payload) {
+  const { projectTypeSummary, ...rest } = payload;
+  return trackShipSucceeded({
+    ...rest,
+    [ShipDimensions.ProjectType]: projectTypeSummary.projectType,
+    [ShipDimensions.ProjectTypes]: projectTypeSummary.projectTypes
+  });
+}
+
+export { normalizeShipProjectType, summarizeShipProjectTypes, unzipProjectManifests, inspectSolutionPackageProjectTypes, trackSolutionShipSucceeded };
+
+//# debugId=6877A4F6FFB0570C64756E2164756E21

package/dist/packager-tool-b03rva43.js

@@ -0,0 +1,188 @@
+import {
+  ProjectPackager,
+  ProjectPublisher,
+  ToolLogger,
+  setGlobalLogHandler
+} from "./packager-tool-n5d5dx5j.js";
+import {
+  ToolResult,
+  translate
+} from "./packager-tool-pbmqk39a.js";
+import {
+  DebugTelemetryProvider,
+  NodeContextStorage
+} from "./packager-tool-tx834spe.js";
+import {
+  TelemetryService
+} from "./packager-tool-6ybywxxn.js";
+import {
+  NodeFileSystem
+} from "./packager-tool-v1f5e8t9.js";
+// ../packager/project-packager/src/base-node-packager-factory.ts
+class BaseNodePackagerFactory {
+  dotnetDiscovery;
+  getOrCreateFileSystem(config) {
+    return config?.fileSystem ?? new NodeFileSystem;
+  }
+  getOrCreateTelemetryService(config) {
+    if (config?.telemetryService) {
+      return config.telemetryService;
+    }
+    const provider = new DebugTelemetryProvider;
+    const contextStorage = new NodeContextStorage;
+    return new TelemetryService(provider, contextStorage);
+  }
+  checkDotnetAvailability(logger) {
+    if (!this.dotnetDiscovery) {
+      return;
+    }
+    const version = this.dotnetDiscovery.getDotnetVersion();
+    if (version) {
+      logger.info(translate.t("solutionpackager.dotnet.info.available", {
+        version
+      }));
+    } else {
+      logger.warn(translate.t("solutionpackager.dotnet.warnings.notAvailable"));
+    }
+  }
+  configureLogHandler(config) {
+    if (config?.logHandler) {
+      setGlobalLogHandler(config.logHandler);
+    }
+  }
+  configureLanguage(config) {
+    const language = config?.language ?? "en";
+    translate.setLocale(language);
+  }
+}
+// ../packager/project-packager/src/services/dotnet-discovery-service.ts
+import { execSync } from "node:child_process";
+
+class DotnetDiscoveryService {
+  cachedVersion;
+  isDotnetAvailable() {
+    return this.getDotnetVersion() !== undefined;
+  }
+  getDotnetVersion() {
+    if (this.cachedVersion !== undefined) {
+      return this.cachedVersion;
+    }
+    try {
+      const output = execSync("dotnet --version", {
+        stdio: ["ignore", "pipe", "ignore"],
+        encoding: "utf-8"
+      });
+      this.cachedVersion = output.trim();
+      return this.cachedVersion;
+    } catch {
+      return;
+    }
+  }
+}
+
+// ../packager/project-packager/src/services/package-sign-service.ts
+import { spawn } from "node:child_process";
+class NodePackageSignService {
+  dotnetDiscovery;
+  logger;
+  constructor(dotnetDiscovery, logger) {
+    this.dotnetDiscovery = dotnetDiscovery;
+    this.logger = logger;
+  }
+  async signPackageAsync(packagePath, certificatePath, certificatePassword, timestampServer) {
+    return this.signPackagesAsync([packagePath], certificatePath, certificatePassword, timestampServer);
+  }
+  async signPackagesAsync(packagePaths, certificatePath, certificatePassword, timestampServer) {
+    if (packagePaths.length === 0) {
+      return ToolResult.success();
+    }
+    if (!this.dotnetDiscovery.isDotnetAvailable()) {
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.signing.errors.dotnetNotAvailable"));
+    }
+    const args = [
+      "nuget",
+      "sign",
+      ...packagePaths,
+      "--certificate-path",
+      certificatePath,
+      "--overwrite"
+    ];
+    if (certificatePassword) {
+      args.push("--certificate-password", certificatePassword);
+    }
+    if (timestampServer) {
+      args.push("--timestamper", timestampServer);
+    }
+    return new Promise((resolve) => {
+      const childProcess = spawn("dotnet", args, {
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: false,
+        windowsHide: true
+      });
+      let stderr = "";
+      childProcess.stdout?.on("data", (data) => {
+        this.logger.info(data.toString().trim());
+      });
+      childProcess.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      childProcess.on("error", (error) => {
+        this.logger.error(`Failed to start dotnet process: ${error.message}`);
+        resolve(ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Failed to start dotnet process: ${error.message}`));
+      });
+      childProcess.on("exit", (code) => {
+        if (code === 0) {
+          this.logger.info(`Successfully signed packages: ${packagePaths.join(", ")}`);
+          resolve(ToolResult.success());
+        } else {
+          const errorMessage = stderr.trim() || `dotnet nuget sign exited with code ${code}`;
+          this.logger.error(`Package signing failed: ${errorMessage}`);
+          resolve(ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Package signing failed: ${errorMessage}`));
+        }
+      });
+    });
+  }
+}
+
+// ../packager/project-packager/src/node-project-packager-factory.ts
+class NodeProjectPackagerFactory extends BaseNodePackagerFactory {
+  async createAsync(config) {
+    const logger = new ToolLogger("ProjectPackagerFactory", "Create");
+    this.configureLanguage(config);
+    this.configureLogHandler(config);
+    logger.info("Creating ProjectPackager instance...");
+    const fileSystem = this.getOrCreateFileSystem(config);
+    const telemetryService = this.getOrCreateTelemetryService(config);
+    this.dotnetDiscovery = new DotnetDiscoveryService;
+    const packageSignService = new NodePackageSignService(this.dotnetDiscovery, logger);
+    const projectPackager = new ProjectPackager(fileSystem, telemetryService, packageSignService);
+    this.checkDotnetAvailability(logger);
+    logger.info("ProjectPackager created successfully.");
+    return projectPackager;
+  }
+}
+async function createNodeProjectPackager(options) {
+  const factory = new NodeProjectPackagerFactory;
+  return factory.createAsync(options);
+}
+// ../packager/project-packager/src/publish/node-project-publisher-factory.ts
+class NodeProjectPublisherFactory extends BaseNodePackagerFactory {
+  async createAsync(config) {
+    const logger = new ToolLogger("ProjectPublisherFactory", "Create");
+    this.configureLanguage(config);
+    this.configureLogHandler(config);
+    logger.info("Creating ProjectPublisher instance...");
+    const fileSystem = this.getOrCreateFileSystem(config);
+    this.getOrCreateTelemetryService(config);
+    const projectPublisher = new ProjectPublisher(fileSystem);
+    logger.info("ProjectPublisher created successfully.");
+    return projectPublisher;
+  }
+}
+async function createNodeProjectPublisher(options) {
+  const factory = new NodeProjectPublisherFactory;
+  return factory.createAsync(options);
+}
+export { BaseNodePackagerFactory, DotnetDiscoveryService, NodePackageSignService, createNodeProjectPackager, createNodeProjectPublisher };
+
+//# debugId=D4A8E25A7C76BDD464756E2164756E21

package/dist/{packager-tool-e2rtr49j.js → packager-tool-b2nhscfk.js}

@@ -1,38 +1,21 @@
+import {
+  toolOwnedProjectTypes,
+  toolVerbForProjectType
+} from "./packager-tool-60af1hw2.js";
 import {
   registerPackagerFactories
-} from "./packager-tool-zns6n8zp.js";
+} from "./packager-tool-5ddtwzva.js";
 import {
   toolsFactoryRepository
-} from "./packager-tool-fv7xyzg2.js";
+} from "./packager-tool-pbmqk39a.js";
 import {
-  catchError,
   ensurePackagerFactory,
   logger,
   unsupportedSolutionProjectType
-} from "./packager-tool-kswwd3hp.js";
-
-// src/services/project-type-tools.ts
-var PROJECT_TYPE_TO_TOOL = new Map([
-  ["Process", "rpa"],
-  ["Tests", "rpa"],
-  ["WebApp", "rpa"],
-  ["AppV2", "codedapp"],
-  ["Api", "api-workflow"],
-  ["Agent", "agent"],
-  ["Function", "function"],
-  ["CaseManagement", "maestro"],
-  ["ProcessOrchestration", "maestro"],
-  ["processOrchestration", "maestro"],
-  ["Flow", "maestro"],
-  ["BusinessRules", "maestro"],
-  ["Entity", "df"]
-]);
-function toolVerbForProjectType(projectType) {
-  return PROJECT_TYPE_TO_TOOL.get(projectType);
-}
-function toolOwnedProjectTypes() {
-  return [...PROJECT_TYPE_TO_TOOL.keys()];
-}
+} from "./packager-tool-tx834spe.js";
+import {
+  catchError
+} from "./packager-tool-6ybywxxn.js";
 
 // src/services/packager-tool-resolver.ts
 var PACKAGER_OWNED_TYPES = ["Connector"];
@@ -90,9 +73,10 @@ function packableProjectTypes() {
   types.delete("processOrchestration");
   return [...types].sort((a, b) => a.localeCompare(b));
 }
-async function ensurePackagerTools(solutionDir, fs) {
+async function ensurePackagerTools(solutionDir, fs, options) {
   registerPackagerFactories();
-  const projects = await readSolutionProjects(solutionDir, fs);
+  const only = options?.onlyProjectRelativePath;
+  const projects = (await readSolutionProjects(solutionDir, fs)).filter((project) => only === undefined || project.path === only);
   if (projects.length === 0)
     return;
   const neededTools = new Set;
@@ -120,6 +104,6 @@ async function ensurePackagerTools(solutionDir, fs) {
   }
 }
 
-export { toolVerbForProjectType, UnpackableProjectTypeError, isUnpackableProjectTypeError, ensurePackagerTools };
+export { UnpackableProjectTypeError, isUnpackableProjectTypeError, ensurePackagerTools };
 
-//# debugId=CA0FE03AC2FB807A64756E2164756E21
+//# debugId=CFEFCC90AA8142B364756E2164756E21