@uipath/solution-tool 1.202.0 → 1.203.0-preview.160

package/dist/{packager-tool-mcpzmn0v.js → packager-tool-rc5pcf2n.js}

@@ -7,7 +7,7 @@ import {
   listSelectablePublishLocations,
   resolveFeedScope,
   resolvePersonalWorkspace
-} from "./packager-tool-5518wy6n.js";
+} from "./packager-tool-cp07fhx3.js";
 import {
   Configuration as Configuration2,
   DeploymentOperationStatus,
@@ -16,11 +16,11 @@ import {
   SolutionDeploymentAction,
   deploymentsAutoInstall,
   searchPackageVersions
-} from "./packager-tool-vfcht7hq.js";
+} from "./packager-tool-mj5p341c.js";
 import {
   getSolutionAuthContext,
   resolveFolder
-} from "./packager-tool-rbrcxjch.js";
+} from "./packager-tool-2syrt51a.js";
 import {
   DEFAULT_PAGE_SIZE,
   PollOutcome,
@@ -31,7 +31,7 @@ import {
   mapPollFailure,
   pollUntil,
   processContext
-} from "./packager-tool-fjjh5veg.js";
+} from "./packager-tool-0f0wt9vh.js";
 import {
   __commonJS,
   __require
@@ -7697,6 +7697,43 @@ var $stringify = publicApi.stringify;
 var $visit = visit.visit;
 var $visitAsync = visit.visitAsync;
 
+// src/services/deployment-validation.ts
+var NO_SERVER_REASON = "the server reported no reason.";
+var LOOKUP_TIMEOUT_MS = 15000;
+function boundedScope(scope, signal) {
+  const deadline = AbortSignal.timeout(LOOKUP_TIMEOUT_MS);
+  const abort = signal ? AbortSignal.any([signal, deadline]) : deadline;
+  return async (requestContext) => ({
+    ...await scope?.(requestContext),
+    signal: abort
+  });
+}
+async function describeValidationFailureAsync(deploymentsApi, deploymentKey, deploymentAction, scope, signal) {
+  const [error, validation] = await catchError(deploymentsApi.deploymentsGetValidationResult({ deploymentKey, deploymentAction }, boundedScope(scope, signal)));
+  if (error || !validation) {
+    return NO_SERVER_REASON;
+  }
+  const messages = [
+    ...validation.validationErrors.map((item) => item.text || item.resource),
+    ...validation.resourceValidationErrors.flatMap((resource) => resource.errors.map((item) => item.text || item.resource))
+  ].filter(Boolean);
+  return messages.length > 0 ? messages.join("; ") : NO_SERVER_REASON;
+}
+async function describeDeploymentFailureAsync(auth, deployment, deploymentAction, scope, signal) {
+  const deploymentsApi = new DeploymentsApi(new Configuration2({
+    basePath: auth.basePath,
+    accessToken: auth.accessToken
+  }));
+  const keys = [deployment.key, deployment.installDeploymentKey].filter((key, index, all) => Boolean(key) && all.indexOf(key) === index);
+  for (const key of keys) {
+    const reason = await describeValidationFailureAsync(deploymentsApi, key, deploymentAction, scope, signal);
+    if (reason !== NO_SERVER_REASON) {
+      return reason;
+    }
+  }
+  return NO_SERVER_REASON;
+}
+
 // src/services/personal-workspace-deploy.ts
 async function deployToFeed(auth, target, params) {
   const config = new Configuration2({
@@ -8162,7 +8199,8 @@ async function awaitFeedDeployAsync(auth, scope, options, started, deploymentNam
   }
   const deployment = pollResult.data;
   if (deployment.operationStatus !== "Successful") {
-    return fail3("deploy_failed", `Deployment '${deploymentName}' failed (OperationStatus: ${deployment.operationStatus}).`, `Inspect the deployment with: uip solution deploy list, fix the underlying issue, then deploy again.`);
+    const reason = await describeDeploymentFailureAsync(auth, deployment, SolutionDeploymentAction.Install, scopeOverride, options.signal);
+    return fail3("deploy_failed", `Deployment '${deploymentName}' failed (OperationStatus: ${deployment.operationStatus}): ${reason}`, `Inspect the deployment with: uip solution deploy list, fix the underlying issue, then deploy again.`);
   }
   return {
     ...started,
@@ -8512,7 +8550,7 @@ async function upgradeDeploymentAsync(deploymentKey, options = {}) {
   }
   const status = poll.status;
   if (FAILURE_STATUSES.has(status)) {
-    return fail5("install_failed", `The upgrade of '${deployment.name}' to ${pkg.latestVersion} ended in ${status}: ${await describeValidationFailureAsync(deploymentsApi, draft.key, upgradeScope)}`, "Fix the reported problem, then retry the upgrade.");
+    return fail5("install_failed", `The upgrade of '${deployment.name}' to ${pkg.latestVersion} ended in ${status}: ${await describeValidationFailureAsync(deploymentsApi, draft.key, SolutionDeploymentAction.Upgrade, upgradeScope)}`, "Fix the reported problem, then retry the upgrade.");
   }
   return { ok: true, ...base, status };
 }
@@ -8544,20 +8582,6 @@ async function pollInstallAsync(deploymentsApi, versionChangeKey, scope, timing)
     failure: mapPollFailure(result, `Upgrade ${versionChangeKey}`)
   };
 }
-async function describeValidationFailureAsync(deploymentsApi, versionChangeKey, scope) {
-  const [error, validation] = await catchError(deploymentsApi.deploymentsGetValidationResult({
-    deploymentKey: versionChangeKey,
-    deploymentAction: SolutionDeploymentAction.Upgrade
-  }, scope));
-  if (error || !validation) {
-    return "the server reported no reason.";
-  }
-  const messages = [
-    ...validation.validationErrors.map((item) => item.text || item.resource),
-    ...validation.resourceValidationErrors.flatMap((resource) => resource.errors.map((item) => item.text || item.resource))
-  ].filter(Boolean);
-  return messages.length > 0 ? messages.join("; ") : "the server reported no reason.";
-}
 
 // src/services/packages-list-service.ts
 var fail6 = (reason, message, instructions, exitCode = 1) => ({
@@ -8617,4 +8641,4 @@ async function listPackagesAsync(options = {}) {
 
 export { extractDeploymentErrors, formatDeploymentErrorsAsText, activateDeploymentAsync, listDeploymentsAsync, deployRunAsync, uninstallDeploymentAsync, upgradeDeploymentAsync, listPackagesAsync };
 
-//# debugId=A0AFD052AEAE53CC64756E2164756E21
+//# debugId=C7F5318965ACD96664756E2164756E21

package/dist/packager-tool-resolver-fmjr60x8.js

@@ -0,0 +1,19 @@
+import {
+  UnpackableProjectTypeError,
+  ensurePackagerTools,
+  isUnpackableProjectTypeError,
+  toolVerbForProjectType
+} from "./packager-tool-k4mskzww.js";
+import"./packager-tool-jz2wbfjz.js";
+import"./packager-tool-nzghfa48.js";
+import"./packager-tool-0f0wt9vh.js";
+import"./packager-tool-dfrk01gn.js";
+import"./packager-tool-1de529jm.js";
+export {
+  UnpackableProjectTypeError,
+  ensurePackagerTools,
+  isUnpackableProjectTypeError,
+  toolVerbForProjectType
+};
+
+//# debugId=E7AC0B5156657E9564756E2164756E21

package/dist/{packager-tool-pw7v82j2.js → packager-tool-vas0xg5h.js}

@@ -1,7 +1,7 @@
 import {
   catchError,
   getFileSystem
-} from "./packager-tool-fjjh5veg.js";
+} from "./packager-tool-0f0wt9vh.js";
 
 // src/services/solution-init-service.ts
 var AGENTS_FILENAME = "AGENTS.md";

package/dist/packager-tool-znakt6yw.js

@@ -0,0 +1,188 @@
+import {
+  toolVerbForProjectType
+} from "./packager-tool-k4mskzww.js";
+import {
+  computeEntryPointSpec,
+  createResourceBuilderServices,
+  hasAnyTemplateRow,
+  hasBareTemplateRow,
+  readUipxProjects
+} from "./packager-tool-bkwnetqn.js";
+import {
+  toolsFactoryRepository
+} from "./packager-tool-nzghfa48.js";
+import {
+  catchError,
+  getFileSystem,
+  logger
+} from "./packager-tool-0f0wt9vh.js";
+
+// src/services/project-contributions.ts
+var ENTRY_POINT_RESOURCE_KIND = "process";
+
+class ProjectContributionsError extends Error {
+  contributionErrors;
+  instructions;
+  errorCode = "invalid_argument";
+  contributionCode;
+  constructor(errors) {
+    super(errors.map((e) => e.message).join(`
+`));
+    this.name = "ProjectContributionsError";
+    this.contributionErrors = errors;
+    const instructions = errors.map((e) => e.instructions).filter((i) => typeof i === "string" && i.length > 0);
+    this.instructions = instructions.length > 0 ? [...new Set(instructions)].join(" ") : undefined;
+    const codes = errors.map((e) => e.code);
+    const everyCoded = codes.every((c) => typeof c === "string" && c.length > 0);
+    this.contributionCode = everyCoded && new Set(codes).size === 1 ? codes[0] : undefined;
+  }
+}
+async function collectProjectContributions(solutionDir, fs = getFileSystem()) {
+  const byProject = new Map;
+  const skipped = [];
+  const projects = await readUipxProjects(solutionDir);
+  for (const project of projects) {
+    if (!toolsFactoryRepository.canHandleProject(project.type))
+      continue;
+    const factory = toolsFactoryRepository.getProjectToolFactory(project.type);
+    if (typeof factory.describeResourcesAsync !== "function") {
+      const verb = toolVerbForProjectType(project.type);
+      const update = verb ? `update the tool that provides it ('uip tools install ${verb}')` : "update the tool that provides it";
+      if (!hasBareTemplateRow(project.type) && hasAnyTemplateRow(project.type)) {
+        byProject.set(project.id, {
+          errors: [
+            {
+              code: "contribution_unavailable",
+              message: `Project '${project.name}' (${project.type}) has no resource contribution: the installed tool for its type predates the contract, and ${project.type} artefact resources are generated only from that contribution.`,
+              instructions: `To generate them, ${update}, then re-run the command.`
+            }
+          ]
+        });
+        continue;
+      }
+      const notice = `Project '${project.name}' (${project.type}) was not checked for resource contributions; ${update}.`;
+      skipped.push(notice);
+      logger.warn(notice);
+      continue;
+    }
+    const [describeError, contribution] = await catchError(factory.describeResourcesAsync(project.path, fs));
+    if (describeError) {
+      byProject.set(project.id, {
+        errors: [
+          {
+            code: "contribution_failed",
+            message: `Project '${project.name}' (${project.type}) failed to describe its resource contribution: ${describeError.message}`,
+            instructions: `Fix the reported problem in ${project.path}, then re-run the command.`
+          }
+        ]
+      });
+      continue;
+    }
+    if (contribution)
+      byProject.set(project.id, contribution);
+  }
+  return { byProject, skipped };
+}
+function assertNoContributionErrors(contributions) {
+  const errors = [...contributions.byProject.values()].flatMap((c) => c.errors ?? []);
+  if (errors.length === 0)
+    return;
+  throw new ProjectContributionsError(errors);
+}
+function contributionErrorMessages(contributions) {
+  return [...contributions.byProject.values()].flatMap((c) => c.errors ?? []).map((e) => e.instructions ? `${e.message} ${e.instructions}` : e.message);
+}
+async function applyProjectContributions(solutionDir, contributions, options, fs = getFileSystem()) {
+  const result = {
+    updated: 0,
+    warnings: [...contributions.skipped]
+  };
+  const services = await createResourceBuilderServices();
+  const builder = await services.getSolutionBuilder(solutionDir);
+  try {
+    const solution = await builder.context.loadAsync();
+    const resources = solution?.resources ?? [];
+    const touched = new Set;
+    for (const [projectKey, contribution] of contributions.byProject) {
+      for (const patch of contribution.specPatch ?? []) {
+        const matches = resources.filter((r) => r.projectKey === projectKey && r.kind?.toLowerCase() === patch.kind.toLowerCase());
+        if (matches.length === 0) {
+          const message = `No '${patch.kind}' resource found for project '${projectKey}' — nothing to apply the contributed spec to.`;
+          if (options?.failOnUnmatchedPatch) {
+            throw new Error(message);
+          }
+          result.warnings.push(message);
+          continue;
+        }
+        for (const resource of matches) {
+          if (applySpecValues(resource, patch.values)) {
+            touched.add(resource);
+          }
+        }
+      }
+    }
+    for (const resource of resources) {
+      if (!resource.projectKey)
+        continue;
+      if (resource.kind?.toLowerCase() !== ENTRY_POINT_RESOURCE_KIND) {
+        continue;
+      }
+      const [computeError, computed] = await catchError(computeEntryPointSpec(fs, solutionDir, resource.projectKey));
+      if (computeError) {
+        result.warnings.push(`Failed to read entry points for project '${resource.projectKey}': ${computeError.message}`);
+        continue;
+      }
+      if (!computed)
+        continue;
+      if (applySpecValues(resource, computed))
+        touched.add(resource);
+    }
+    result.updated = touched.size;
+    if (touched.size > 0 && solution) {
+      await builder.context.saveAsync(solution);
+    }
+    return result;
+  } finally {
+    const dispose = builder.disposeAsync;
+    if (typeof dispose === "function") {
+      const [disposeError] = await catchError(dispose.call(builder));
+      if (disposeError) {
+        logger.warn(`Failed to dispose solution builder after applying project contributions: ${disposeError.message}`);
+      }
+    }
+  }
+}
+function applySpecValues(resource, values) {
+  const spec = { ...resource.spec ?? {} };
+  let changed = false;
+  for (const [key, value] of Object.entries(values)) {
+    const existingKey = Object.keys(spec).find((k) => k.toLowerCase() === key.toLowerCase()) ?? key;
+    if (value === null) {
+      if (existingKey in spec) {
+        delete spec[existingKey];
+        changed = true;
+      }
+      continue;
+    }
+    if (isSameSpecValue(spec[existingKey], value))
+      continue;
+    spec[existingKey] = value;
+    changed = true;
+  }
+  if (changed) {
+    resource.spec = spec;
+  }
+  return changed;
+}
+function isSameSpecValue(a, b) {
+  if (a === b)
+    return true;
+  if (typeof a !== "object" || typeof b !== "object" || !a || !b) {
+    return false;
+  }
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+export { ProjectContributionsError, collectProjectContributions, assertNoContributionErrors, contributionErrorMessages, applyProjectContributions };
+
+//# debugId=F82FA56EE24E69EE64756E2164756E21

package/dist/packager-tool.d.ts

@@ -4,7 +4,7 @@
  * factory for Connector, the one project type no CLI tool owns — there is no
  * `connector` verb. Every other project type is registered by the tool that
  * owns it, through that tool's own `packager-tool` entry point, loaded on
- * demand by `ensurePackagerTools` (AGENTS.md Hard Rule #18).
+ * demand by `ensurePackagerTools` (AGENTS.md Hard Rule #19).
  *
  * Explicit, not a module-load side effect: `ensurePackagerTools` calls this at
  * the start of every pack / restore / cleanup, which is the only code that

package/dist/packager-tool.js

@@ -1,6 +1,6 @@
 import {
   registerPackagerFactories
-} from "./packager-tool-3bewrpq4.js";
+} from "./packager-tool-jz2wbfjz.js";
 import"./packager-tool-nzghfa48.js";
 import"./packager-tool-dfrk01gn.js";
 import"./packager-tool-1de529jm.js";

package/dist/prepare-solution-resources-wds3r8bq.js

@@ -0,0 +1,22 @@
+import {
+  prepareSolutionResources,
+  projectSubTypesFrom
+} from "./packager-tool-7znqtw3f.js";
+import"./packager-tool-znakt6yw.js";
+import"./packager-tool-k4mskzww.js";
+import"./packager-tool-jz2wbfjz.js";
+import"./packager-tool-bkwnetqn.js";
+import"./packager-tool-gdtpsdn7.js";
+import"./packager-tool-53w8skv5.js";
+import"./packager-tool-nzghfa48.js";
+import"./packager-tool-2syrt51a.js";
+import"./packager-tool-3jrq7smt.js";
+import"./packager-tool-0f0wt9vh.js";
+import"./packager-tool-dfrk01gn.js";
+import"./packager-tool-1de529jm.js";
+export {
+  prepareSolutionResources,
+  projectSubTypesFrom
+};
+
+//# debugId=9F446E87789120A364756E2164756E21

package/dist/project-contributions-cvttys34.js

@@ -0,0 +1,27 @@
+import {
+  ProjectContributionsError,
+  applyProjectContributions,
+  assertNoContributionErrors,
+  collectProjectContributions,
+  contributionErrorMessages
+} from "./packager-tool-znakt6yw.js";
+import"./packager-tool-k4mskzww.js";
+import"./packager-tool-jz2wbfjz.js";
+import"./packager-tool-bkwnetqn.js";
+import"./packager-tool-gdtpsdn7.js";
+import"./packager-tool-53w8skv5.js";
+import"./packager-tool-nzghfa48.js";
+import"./packager-tool-2syrt51a.js";
+import"./packager-tool-3jrq7smt.js";
+import"./packager-tool-0f0wt9vh.js";
+import"./packager-tool-dfrk01gn.js";
+import"./packager-tool-1de529jm.js";
+export {
+  ProjectContributionsError,
+  applyProjectContributions,
+  assertNoContributionErrors,
+  collectProjectContributions,
+  contributionErrorMessages
+};
+
+//# debugId=5BEB743E097B870464756E2164756E21

package/dist/publish.js

@@ -1,14 +1,15 @@
 import {
   publishSolutionAsync
-} from "./packager-tool-pyygbnp2.js";
-import"./packager-tool-5518wy6n.js";
-import"./packager-tool-vfcht7hq.js";
-import"./packager-tool-rbrcxjch.js";
-import"./packager-tool-fjjh5veg.js";
+} from "./packager-tool-htag6yh5.js";
+import"./packager-tool-cp07fhx3.js";
+import"./packager-tool-mj5p341c.js";
+import"./packager-tool-2syrt51a.js";
+import"./packager-tool-3jrq7smt.js";
+import"./packager-tool-0f0wt9vh.js";
 import"./packager-tool-dfrk01gn.js";
 import"./packager-tool-1de529jm.js";
 export {
   publishSolutionAsync
 };
 
-//# debugId=AD7DDE48BF35E04564756E2164756E21
+//# debugId=C6A6B2A4D9E3236B64756E2164756E21

package/dist/resource.js

@@ -1,13 +1,16 @@
 import {
   resourceRefreshAsync
-} from "./packager-tool-bt0z25tw.js";
+} from "./packager-tool-bkwnetqn.js";
+import"./packager-tool-gdtpsdn7.js";
+import"./packager-tool-53w8skv5.js";
 import"./packager-tool-nzghfa48.js";
-import"./packager-tool-rbrcxjch.js";
-import"./packager-tool-fjjh5veg.js";
+import"./packager-tool-2syrt51a.js";
+import"./packager-tool-3jrq7smt.js";
+import"./packager-tool-0f0wt9vh.js";
 import"./packager-tool-dfrk01gn.js";
 import"./packager-tool-1de529jm.js";
 export {
   resourceRefreshAsync
 };
 
-//# debugId=54ED39ED9D918B1A64756E2164756E21
+//# debugId=EF371AE5DDFD388A64756E2164756E21

package/dist/services/deployment-validation.d.ts

@@ -0,0 +1,33 @@
+import type { InitOverrideFunction } from "@uipath/solution-sdk";
+import { DeploymentsApi, type SolutionDeploymentAction } from "@uipath/solution-sdk";
+import type { SolutionAuthContext } from "@uipath/solution-sdk/auth";
+export declare const NO_SERVER_REASON = "the server reported no reason.";
+/**
+ * How long one validation lookup may take.
+ *
+ * This runs after the caller's wait has already ended, so it has no budget
+ * left to inherit, and the generated SDK hands the request to `fetch` without
+ * a deadline of its own. Unbounded, a stalled lookup outlives `--timeout` and
+ * the command sits there instead of returning the failure it already knows
+ * about.
+ */
+export declare const LOOKUP_TIMEOUT_MS = 15000;
+/**
+ * Ask the server why an install/upgrade failed. Deployment records carry a
+ * status and no error field, so the validation result is the only place an
+ * actionable cause lives (e.g. `SolutionFolderNotFound`).
+ *
+ * Best-effort: this runs on an already-failing path, so a second failure here
+ * must not replace the caller's message with a transport error.
+ */
+export declare function describeValidationFailureAsync(deploymentsApi: DeploymentsApi, deploymentKey: string, deploymentAction: SolutionDeploymentAction, scope: InitOverrideFunction | undefined, signal?: AbortSignal): Promise<string>;
+/**
+ * The same question for a deployment known only from its search record.
+ *
+ * A search row carries two keys and the API documents neither, so ask with
+ * `key` and fall back to `installDeploymentKey` when that answers nothing.
+ */
+export declare function describeDeploymentFailureAsync(auth: SolutionAuthContext, deployment: {
+    key: string;
+    installDeploymentKey?: string;
+}, deploymentAction: SolutionDeploymentAction, scope: InitOverrideFunction | undefined, signal?: AbortSignal): Promise<string>;

package/dist/services/governance-options.d.ts

@@ -1,3 +1,5 @@
+import type { IFileSystem } from "@uipath/filesystem";
+import { RulesConfigFileType } from "@uipath/solution-packager/node";
 import type { PackCommandOptions } from "../models";
 /**
  * What to do about a rejected governance option. Pairs with the message
@@ -23,4 +25,62 @@ export declare const GOVERNANCE_OPTION_INSTRUCTIONS: string;
  * `Message` from `Instructions`. Owning the wording here keeps the two paths
  * from drifting apart.
  */
-export declare function validateGovernanceOptions(options: Pick<PackCommandOptions, "governanceFilePath" | "automationOpsProfile">): string | null;
+export declare function validateGovernanceOptions(options: Pick<PackCommandOptions, "governanceFilePath" | "governanceProduct" | "automationOpsProfile">): string | null;
+/** What {@link detectGovernanceFileType} concluded about a policy file. */
+export type GovernanceFileDetection = {
+    kind: "detected";
+    fileType: RulesConfigFileType;
+} | {
+    kind: "unparseable";
+} | {
+    kind: "unwrapped-automation-ops";
+};
+/**
+ * Work out which rules-config source a local policy file belongs to.
+ *
+ * This exists because the compiler's `--policy-file-type` decides whether the
+ * policy is applied at all, and it does not fall back: handed an AutomationOps
+ * policy under `Studio`, the analyzer runs, reports nothing, and the pack
+ * succeeds — a policy escalating a rule to Error is silently discarded. The
+ * CLI has no flag for the type (`--governance-file-path` used to hardcode
+ * `Studio`), so a user's only realistic policy source — an AutomationOps
+ * export — never took effect.
+ *
+ * Anything that parses as JSON but carries no AutomationOps rule table is
+ * passed through as `Studio`. That is Studio's own rules-configuration format,
+ * whose schema lives inside the WorkflowCompiler, so the CLI cannot recognise
+ * it positively and must not reject it.
+ */
+export declare function detectGovernanceFileType(source: string): GovernanceFileDetection;
+/** Failure message for a policy file that could not be read. */
+export declare function governanceFileUnreadableMessage(path: string): string;
+/** Failure message for an AutomationOps policy stripped of its envelope. */
+export declare function governanceFileUnwrappedMessage(path: string): string;
+/** Failure message for a policy file that is not JSON. */
+export declare function governanceFileUnparseableMessage(path: string): string;
+/**
+ * Remedy for both read failures above. Deliberately does not say "drop the
+ * flag": the user asked for a policy, and packing without one would be the
+ * silent no-op this check exists to remove.
+ */
+export declare const GOVERNANCE_FILE_UNUSABLE_INSTRUCTIONS: string;
+/** Outcome of resolving `--governance-file-path` to a rules-config source. */
+export type GovernanceFileTypeResult = {
+    ok: true;
+    fileType: RulesConfigFileType;
+} | {
+    ok: false;
+    message: string;
+    instructions: string;
+};
+/**
+ * Read the policy file named by `--governance-file-path` and decide which
+ * rules-config source it belongs to.
+ *
+ * Reading it here, rather than leaving it to the packager's options validator,
+ * is what makes the choice possible at all: the type has to travel with the
+ * path, and the only way to tell the two formats apart is to look inside. A
+ * file that cannot be read or is not JSON fails the pack instead of falling
+ * back to a source that would discard it.
+ */
+export declare function resolveGovernanceFileTypeAsync(fs: IFileSystem, governanceFilePath: string): Promise<GovernanceFileTypeResult>;

package/dist/services/pack-command-service.d.ts

@@ -1,4 +1,4 @@
-import { type CommandContext } from "@uipath/common";
+import { type CliErrorCode, type CommandContext, RESULTS, type RetryHint } from "@uipath/common";
 import { ToolResult } from "@uipath/solutionpackager-tool-core";
 import type { PackCommandOptions } from "../models";
 /**
@@ -23,7 +23,8 @@ export declare class PackCommandService {
     execute(solutionPath: string, options: PackCommandOptions, context: CommandContext): Promise<void>;
     /**
      * The entry guards `executeAsync` runs before it touches a packager:
-     * a missing output path, bad governance options, and a solution path that
+     * a missing output path, bad governance options, a governance policy file
+     * whose rules-config source cannot be derived, and a solution path that
      * is absent or unreadable. Split out so `executeAsync` stays inside the
      * cognitive-complexity budget; each one still returns the `ToolResult`
      * that caller expects rather than throwing.
@@ -74,3 +75,33 @@ export declare class PackCommandService {
     private resolvePackageName;
     private createPackOptions;
 }
+/**
+ * The failure envelope for a pack the packager refused.
+ *
+ * Most failures keep the shape they have always had — `Error code: <tool code>
+ * : <message>` with the packager's own text as the next step — because the
+ * cause is whatever the compiler reported and there is nothing better to say.
+ * A member package id we know is unpublishable is different: the cause is a
+ * name on disk (a member folder, the `.uipx`), so it gets `invalid_argument`, a
+ * message without the tool-code prefix, and instructions naming what to
+ * rename. Agents branch on `ErrorCode`, and `unknown_error` there tells them
+ * this can never be fixed by the caller, which is the opposite of true.
+ *
+ * Instructions the packager carried up beat the generic next step, which for a
+ * non-dry-run pack is the message itself.
+ */
+export declare function packFailureEnvelope(result: {
+    errorCode: string;
+    message?: string;
+    instructions?: string;
+    details?: ToolResult["details"];
+}, dryRun: boolean): {
+    Result: typeof RESULTS.Failure;
+    Message: string;
+    Instructions: string;
+    ErrorCode?: CliErrorCode;
+    Retry?: RetryHint;
+    Data?: {
+        Projects: unknown[];
+    };
+};

package/dist/services/packager-tool-resolver.d.ts

@@ -1,3 +1,4 @@
+import { type CliErrorCode } from "@uipath/common";
 import type { IFileSystem } from "@uipath/filesystem";
 /**
  * A `.uipx` names a project type nothing can pack, and no tool provides one.
@@ -12,10 +13,12 @@ import type { IFileSystem } from "@uipath/filesystem";
 export declare class UnpackableProjectTypeError extends Error {
     readonly __unpackableType = true;
     readonly instructions: string;
+    readonly errorCode: CliErrorCode;
     constructor(projectType: string, projectPath: string);
 }
 /** True when `error` is an {@link UnpackableProjectTypeError}, duck-typed. */
 export declare function isUnpackableProjectTypeError(error: unknown): boolean;
+export { toolVerbForProjectType } from "./project-type-tools";
 /**
  * Puts every factory this pack needs in `toolsFactoryRepository`: registers
  * the ones solution-tool owns, then reads project types from the .uipx and

package/dist/services/prepare-solution-resources.d.ts

@@ -0,0 +1,40 @@
+import type { IFileSystem } from "@uipath/filesystem";
+import { type ProjectContributions } from "./project-contributions";
+export interface PrepareResult {
+    /** Contributed problems (when not gating), skips, and unmatched patches. */
+    warnings: string[];
+    /** Artefact resources whose spec was rewritten. */
+    updated: number;
+}
+/**
+ * The projects that told us which template variant their artefact resources
+ * come from, keyed by `.uipx` project `Id`. Opaque strings: the value is
+ * produced by the tool that owns the project type and consumed by the SDK's
+ * reconciler, and nothing in between reads it (AGENTS.md Hard Rule #19).
+ */
+export declare function projectSubTypesFrom(contributions: ProjectContributions): ReadonlyMap<string, string>;
+/**
+ * Bring a solution directory's resource JSONs in line with its projects'
+ * authored files. Every path that reads those resources for real — `pack`,
+ * `upload`, `resources refresh` — runs this, so a coded app gets the same
+ * treatment whichever one the user reaches for.
+ *
+ * The order is load-bearing:
+ *
+ * 1. `ensurePackagerTools` — the collect dispatches to registered factories.
+ * 2. collect — reads project files only, which the sync never touches, so
+ *    collecting before and applying after cannot see two different states.
+ * 3. gate (pack, upload) — a project reporting a problem with its own files
+ *    must fail before any write, not leave half-synced resources behind.
+ * 4. sync — carries the contributed subTypes, which is what lets reconcile
+ *    generate (or repair) artefact resources for a type whose template row is
+ *    keyed `<type>_<subType>`.
+ * 5. apply — after the sync, because the sync can create the app resource a
+ *    patch targets. An unmatched patch here is a contributor bug, not a race,
+ *    which is why gating callers also fail on one.
+ * 6. runtime dependencies — mirrors Orchestrator BE's
+ *    `ProcessesExportHandlerBase.GetRuntimeDependenciesAsync`.
+ */
+export declare function prepareSolutionResources(solutionDir: string, fs: IFileSystem, options?: {
+    gate?: boolean;
+}): Promise<PrepareResult>;