@uipath/solution-tool 1.203.0-preview.203 → 1.204.0-preview.206

package/dist/{packager-tool-7znqtw3f.js → packager-tool-9vvdgbay.js}

@@ -3,10 +3,10 @@ import {
   assertNoContributionErrors,
   collectProjectContributions,
   contributionErrorMessages
-} from "./packager-tool-znakt6yw.js";
+} from "./packager-tool-vh4ng74p.js";
 import {
   ensurePackagerTools
-} from "./packager-tool-k4mskzww.js";
+} from "./packager-tool-5dzjsw5q.js";
 import {
   Tokens,
   createResourceBuilderServices,
@@ -17,12 +17,14 @@ import {
   models_BindingsResourceType,
   readUipxProjects,
   syncAndLog
-} from "./packager-tool-bkwnetqn.js";
+} from "./packager-tool-83rzavkx.js";
 import {
   catchError,
-  getFileSystem,
   logger
-} from "./packager-tool-0f0wt9vh.js";
+} from "./packager-tool-5fjp60dk.js";
+import {
+  getFileSystem
+} from "./packager-tool-zf3929se.js";
 
 // src/services/emit-runtime-dependencies.ts
 import { createHash } from "node:crypto";
@@ -241,4 +243,4 @@ async function prepareSolutionResources(solutionDir, fs, options) {
 
 export { projectSubTypesFrom, prepareSolutionResources };
 
-//# debugId=66D4CB702D8B08F964756E2164756E21
+//# debugId=16FA8B6372D1A69964756E2164756E21

package/dist/packager-tool-b8pppqbb.js

@@ -0,0 +1,172 @@
+import {
+  findDeploymentByName,
+  findLiveDeploymentByName
+} from "./packager-tool-myn57mc3.js";
+import {
+  folderKeyInitOverride,
+  listSelectablePublishLocations,
+  resolvePersonalWorkspace
+} from "./packager-tool-dh0m3ebf.js";
+import {
+  catchError,
+  extractErrorDetails
+} from "./packager-tool-5fjp60dk.js";
+
+// src/services/deployment-feed-locator.ts
+var sweepResult = (location, skipped) => ({
+  location,
+  skipped,
+  complete: skipped.length === 0
+});
+async function nonTenantFeedsAsync(options) {
+  const [listError, locations] = await catchError(listSelectablePublishLocations({
+    tenant: options.tenant,
+    loginValidity: options.loginValidity,
+    envFilePath: options.envFilePath
+  }));
+  if (!listError) {
+    const rank = (location) => location.type === "PersonalWorkspace" ? 0 : 1;
+    const feeds = [];
+    const skipped2 = [];
+    const nonTenant = [...locations].filter((location) => location.type !== "Tenant").sort((a, b) => rank(a) - rank(b));
+    for (const location of nonTenant) {
+      const kind = location.type === "PersonalWorkspace" ? "personal" : "folder";
+      if (location.key) {
+        feeds.push({ kind, folderKey: location.key });
+        continue;
+      }
+      skipped2.push({
+        kind,
+        reason: "no_key",
+        name: location.name,
+        error: new Error(`The list of feeds returned ${kind === "personal" ? "the Personal Workspace" : `folder feed '${location.name}'`} with no folder key, so it could not be searched.`)
+      });
+    }
+    return { feeds, skipped: skipped2 };
+  }
+  const skipped = [
+    { kind: "folder", reason: "listing_failed", error: listError }
+  ];
+  const [workspaceError, personalWorkspace] = await catchError(resolvePersonalWorkspace({
+    tenant: options.tenant,
+    loginValidity: options.loginValidity,
+    envFilePath: options.envFilePath
+  }));
+  if (workspaceError) {
+    skipped.push({
+      kind: "personal",
+      reason: "workspace_unresolved",
+      error: workspaceError
+    });
+  }
+  return {
+    feeds: personalWorkspace?.key ? [{ kind: "personal", folderKey: personalWorkspace.key }] : [],
+    skipped
+  };
+}
+async function findDeploymentAcrossFeeds(auth, deploymentName, options) {
+  const find = options.includeUninstalled ? findDeploymentByName : findLiveDeploymentByName;
+  const [tenantError, tenantMatch] = await catchError(find(auth, deploymentName));
+  if (tenantError) {
+    return sweepResult(undefined, [
+      { kind: "tenant", reason: "search_failed", error: tenantError }
+    ]);
+  }
+  if (tenantMatch) {
+    return sweepResult({ deployment: tenantMatch }, []);
+  }
+  const { feeds, skipped } = await nonTenantFeedsAsync(options);
+  for (const feed of feeds) {
+    const scope = folderKeyInitOverride(feed.folderKey);
+    const [searchError, deployment] = await catchError(find(auth, deploymentName, scope));
+    if (searchError) {
+      skipped.push({
+        ...feed,
+        reason: "search_failed",
+        error: searchError
+      });
+      continue;
+    }
+    if (deployment) {
+      return sweepResult({ deployment, scope, feed }, skipped);
+    }
+  }
+  return sweepResult(undefined, skipped);
+}
+
+// src/services/incomplete-feed-sweep.ts
+function isNameOrFeedRefusal(errorCode, httpStatus) {
+  return errorCode === "not_found" || errorCode === "invalid_argument" && httpStatus === 400;
+}
+var INCOMPLETE_SWEEP_ADVICE = "The deployment may be in a feed that was not searched.";
+function describeSkippedFeed(feed) {
+  const noKey = feed.reason === "no_key" ? " (the list of feeds gave it no key)" : "";
+  switch (feed.kind) {
+    case "tenant":
+      return "the tenant feed";
+    case "personal":
+      return feed.folderKey ? `your Personal Workspace feed (${feed.folderKey})` : `your Personal Workspace feed${noKey}`;
+    case "folder":
+      if (feed.reason === "listing_failed") {
+        return "the folder feeds (the list of feeds could not be read)";
+      }
+      if (feed.folderKey) {
+        return `folder feed ${feed.folderKey}`;
+      }
+      return feed.name ? `folder feed '${feed.name}'${noKey}` : `a folder feed${noKey}`;
+  }
+}
+function retryAdvice(errorCode, retry, service) {
+  switch (errorCode) {
+    case "authentication_required":
+      return "Run 'uip login' to refresh the session, then retry.";
+    case "permission_denied":
+      return "The account or its token lacks access; check the session and its scopes with 'uip login status --detailed', then retry.";
+    case "network_error":
+      return "Check the connection, then retry.";
+    case "rate_limited":
+      return "Wait a moment, then retry.";
+    default:
+      return retry === "RetryWillNotFix" ? "Retrying alone will not help; fix the cause in the details first." : `Retry once ${service} answers.`;
+  }
+}
+var NO_KEY_NEXT_STEP = "Retrying will not help: the list of feeds gives the skipped feeds no folder key, so neither the search nor --feed can reach them. Run 'uip solution feeds list' to see each feed's Key.";
+var keylessOnly = (skipped) => skipped.length > 0 && skipped.every((feed) => feed.reason === "no_key");
+function oneFeedFlags(skipped) {
+  const flags = [];
+  if (!skipped.some((feed) => feed.reason === "workspace_unresolved")) {
+    flags.push("--personal-workspace");
+  }
+  if (!skipped.some((feed) => feed.reason === "listing_failed") && !keylessOnly(skipped)) {
+    flags.push("--feed <name-or-key>");
+  }
+  return flags;
+}
+function isClassified(cause) {
+  return cause.errorCode !== "not_found" && cause.errorCode !== "unknown_error";
+}
+async function reportIncompleteSweepAsync(deploymentName, skipped) {
+  const feeds = skipped.map(describeSkippedFeed).join(", ");
+  const causes = await Promise.all(skipped.map((feed) => extractErrorDetails(feed.error)));
+  const cause = causes.find(isClassified) ?? causes[0] ?? await extractErrorDetails(undefined);
+  const unclassified = !isClassified(cause);
+  const keyless = keylessOnly(skipped);
+  const errorCode = unclassified ? "unknown_error" : cause.errorCode;
+  let retry = unclassified ? "RetryLater" : cause.retry;
+  if (keyless) {
+    retry = "RetryWillNotFix";
+  }
+  const message = skipped.some((feed) => feed.kind === "tenant") ? `Could not look up deployment '${deploymentName}': ${feeds} could not be searched.` : `Deployment '${deploymentName}' was not found in the feeds that answered, but these could not be searched: ${feeds}.`;
+  return {
+    message,
+    errorCode,
+    retry,
+    details: cause.details,
+    nextStep: keyless ? NO_KEY_NEXT_STEP : retryAdvice(errorCode, retry, "the feed service"),
+    oneFeedFlags: oneFeedFlags(skipped)
+  };
+}
+
+export { findDeploymentAcrossFeeds, isNameOrFeedRefusal, INCOMPLETE_SWEEP_ADVICE, retryAdvice, reportIncompleteSweepAsync };
+
+//# debugId=43A92F098DF7C11664756E2164756E21

package/dist/packager-tool-bqre28m1.js

@@ -0,0 +1,43 @@
+import {
+  resolveSessionIdentity
+} from "./packager-tool-gb35b4qs.js";
+
+// src/services/feed-session.ts
+function classifyFeedSession(session) {
+  const type = (session.identity ?? resolveSessionIdentity(session.accessToken))?.type;
+  if (type === "User") {
+    return "user";
+  }
+  return type === "Application" ? "application" : "unknown";
+}
+function feedSessionRefusal(verdict, action, alternative) {
+  if (verdict === "application") {
+    return {
+      message: `${action} needs a user session; this session is an external app.`,
+      instructions: `The server does not apply X-UIPATH-FolderKey to client-credentials requests, so the request would run against the tenant feed instead. Run it with a user session ('uip login'), or ${alternative}.`
+    };
+  }
+  return {
+    message: `${action} needs a user session, and this session's kind could not be read from its token.`,
+    instructions: `The server applies X-UIPATH-FolderKey to user-token requests only, and a session that cannot be shown to be a user's is not allowed to act on a feed — guessing wrong would run the request against the tenant feed. Refresh the session with 'uip login' (an interactive login is recorded as a user session), or ${alternative}.`
+  };
+}
+function feedReadRefusalForApplication(session, action) {
+  if (classifyFeedSession(session) !== "application") {
+    return;
+  }
+  return feedSessionRefusal("application", action, "drop the feed flag to read the tenant feed");
+}
+
+class FeedReadRefusedError extends Error {
+  refusal;
+  constructor(refusal) {
+    super(refusal.message);
+    this.refusal = refusal;
+    this.name = "FeedReadRefusedError";
+  }
+}
+
+export { classifyFeedSession, feedSessionRefusal, feedReadRefusalForApplication, FeedReadRefusedError };
+
+//# debugId=46593028C6477B8B64756E2164756E21

package/dist/packager-tool-dh0m3ebf.js

@@ -0,0 +1,173 @@
+import {
+  getAvailablePublishLocationsV2
+} from "./packager-tool-t12hj6pd.js";
+import {
+  classifyFeedSession
+} from "./packager-tool-bqre28m1.js";
+import {
+  PersonalWorkspacesApi,
+  createOrchestratorConfig
+} from "./packager-tool-3fv6zc86.js";
+import {
+  extractErrorDetails
+} from "./packager-tool-5fjp60dk.js";
+import {
+  getLoginStatusAsync
+} from "./packager-tool-gb35b4qs.js";
+
+// src/services/personal-workspace-resolver.ts
+async function resolvePersonalWorkspace(options) {
+  const config = await createOrchestratorConfig(options);
+  const api = new PersonalWorkspacesApi(config);
+  const pw = await api.personalWorkspacesGetPersonalWorkspace();
+  if (!pw?.key || !pw.name) {
+    throw new Error("Personal Workspace not configured for the current user. " + "Enable Personal Workspace in Orchestrator (or sign in as a user that has one), then retry.");
+  }
+  return { key: pw.key, name: pw.name };
+}
+
+// src/services/publish-locations-service.ts
+async function resolveStudioWebTarget(options) {
+  const loginStatus = await getLoginStatusAsync({
+    ensureTokenValidityMinutes: options?.loginValidity,
+    envFilePath: options?.envFilePath
+  });
+  if (loginStatus.loginStatus !== "Logged in" || !loginStatus.accessToken || !loginStatus.baseUrl) {
+    throw new Error("Not logged in. Run 'uip login' first.");
+  }
+  if (!loginStatus.organizationName) {
+    throw new Error("Organization name is not available. Re-authenticate with 'uip login'.");
+  }
+  if (options?.tenant && loginStatus.tenantName && options.tenant.toLowerCase() !== loginStatus.tenantName.toLowerCase()) {
+    throw new Error(`Feeds are resolved for the logged-in tenant ('${loginStatus.tenantName}'), so --tenant '${options.tenant}' can't apply here. Switch tenants first with: uip login tenant set ${options.tenant}.`);
+  }
+  return {
+    config: {
+      baseUrl: loginStatus.baseUrl,
+      authToken: loginStatus.accessToken,
+      tenantId: loginStatus.tenantId
+    },
+    organizationName: loginStatus.organizationName
+  };
+}
+function isSelectableFeed(location) {
+  switch (location.type) {
+    case "Tenant":
+    case "Folder":
+      return true;
+    case "PersonalWorkspace":
+      return location.isMyPersonalWorkspace;
+    default:
+      return false;
+  }
+}
+async function listSelectablePublishLocations(options) {
+  const { config, organizationName } = await resolveStudioWebTarget(options);
+  const all = await getAvailablePublishLocationsV2(config, organizationName);
+  return all.filter(isSelectableFeed);
+}
+
+// src/services/feed-resolver.ts
+function folderKeyInitOverride(folderKey) {
+  return async ({ init }) => ({
+    headers: { ...init.headers, "X-UIPATH-FolderKey": folderKey }
+  });
+}
+function feedScopeInitOverride(scope) {
+  const { folderKey } = scope;
+  if (!folderKey) {
+    return;
+  }
+  return folderKeyInitOverride(folderKey);
+}
+function feedSelectorFlag(scope) {
+  if (!scope || scope.kind === "tenant" || !scope.folderKey) {
+    return "";
+  }
+  return scope.kind === "personal" ? " --personal-workspace" : ` --feed ${scope.folderKey}`;
+}
+function feedResolutionFailureInstructions(options) {
+  if (options.personalWorkspace) {
+    return "Personal Workspace resolution needs an interactive user session and an enabled Personal Workspace. Log in as a user with a Personal Workspace, or omit --personal-workspace to use the tenant feed.";
+  }
+  if (options.feed !== undefined) {
+    return "List the feeds you can target with: uip solution feeds list.";
+  }
+  return "Check the selected feed and try again.";
+}
+async function describeFeedResolutionFailureAsync(error, options, session) {
+  const details = await extractErrorDetails(error);
+  if (options.personalWorkspace && isRefusal(details.context?.httpStatus) && classifyFeedSession(session) === "application") {
+    return {
+      message: "--personal-workspace needs a user session; this session is an external app, which has no Personal Workspace.",
+      instructions: "Run it with a user session that has a Personal Workspace ('uip login'). A client-credentials login cannot target one.",
+      errorCode: "permission_denied",
+      retry: "RetryWillNotFix",
+      context: details.context
+    };
+  }
+  return {
+    message: details.message,
+    instructions: feedResolutionFailureInstructions(options),
+    errorCode: details.errorCode,
+    retry: details.retry,
+    context: details.context
+  };
+}
+function isRefusal(status) {
+  return status !== undefined && status >= 400 && status < 500 && status !== 408 && status !== 429;
+}
+async function resolveFeedScope(options) {
+  const { personalWorkspace, feed } = options;
+  if (personalWorkspace && feed !== undefined) {
+    throw new Error("Use either --personal-workspace or --feed, not both.");
+  }
+  if (personalWorkspace) {
+    const pw = await resolvePersonalWorkspace({
+      tenant: options.tenant,
+      loginValidity: options.loginValidity,
+      envFilePath: options.envFilePath
+    });
+    return { kind: "personal", folderKey: pw.key, name: pw.name };
+  }
+  if (feed !== undefined) {
+    return resolveNamedFeed(feed, options);
+  }
+  return { kind: "tenant" };
+}
+async function resolveNamedFeed(feed, options) {
+  const locations = await listSelectablePublishLocations({
+    tenant: options.tenant,
+    envFilePath: options.envFilePath,
+    loginValidity: options.loginValidity
+  });
+  const match = matchFeed(feed, locations);
+  const kind = match.type === "Tenant" ? "tenant" : match.type === "PersonalWorkspace" ? "personal" : "folder";
+  if (kind !== "tenant" && !match.key) {
+    throw new Error(`Feed '${match.name || feed}' has no folder key in the publish-locations response, so it can't be targeted. Run 'uip solution feeds list' and pick a feed with a Key.`);
+  }
+  return {
+    kind,
+    folderKey: kind === "tenant" ? undefined : match.key,
+    name: match.name
+  };
+}
+function matchFeed(feed, locations) {
+  const byKey = locations.find((location) => location.key === feed);
+  if (byKey) {
+    return byKey;
+  }
+  const target = feed.toLowerCase();
+  const byName = locations.filter((location) => location.name.toLowerCase() === target);
+  if (byName.length === 1) {
+    return byName[0];
+  }
+  if (byName.length > 1) {
+    throw new Error(`More than one feed is named '${feed}'. Pass its key instead — ` + "'uip solution feeds list' shows each feed's key.");
+  }
+  throw new Error(`Feed '${feed}' is not an available publish location. ` + "Run 'uip solution feeds list' to see the feeds you can publish to.");
+}
+
+export { resolvePersonalWorkspace, listSelectablePublishLocations, folderKeyInitOverride, feedScopeInitOverride, feedSelectorFlag, feedResolutionFailureInstructions, describeFeedResolutionFailureAsync, resolveFeedScope };
+
+//# debugId=F37E07288EA6F3E164756E2164756E21

package/dist/packager-tool-f5gq77m5.js

@@ -0,0 +1,28 @@
+import {
+  getAuthContext
+} from "./packager-tool-gb35b4qs.js";
+
+// ../solution-sdk/src/solution-auth.ts
+async function getSolutionAuthContext(options) {
+  const ctx = await getAuthContext({
+    tenant: options.tenant,
+    ensureTokenValidityMinutes: options.loginValidity ?? 10,
+    envFilePath: options.envFilePath,
+    requireOrganizationId: true,
+    requireTenantName: true
+  });
+  const organizationId = ctx.organizationId;
+  const tenantName = ctx.tenantName;
+  const basePath = `${ctx.baseUrl}/${organizationId}/${tenantName}/automationsolutions_`;
+  return {
+    accessToken: ctx.accessToken,
+    basePath,
+    organizationId,
+    tenantName,
+    identity: ctx.identity
+  };
+}
+
+export { getSolutionAuthContext };
+
+//# debugId=7C83D4398979D25864756E2164756E21