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

package/dist/{packager-tool-znakt6yw.js → packager-tool-vh4ng74p.js}

@@ -1,21 +1,23 @@
 import {
   toolVerbForProjectType
-} from "./packager-tool-k4mskzww.js";
+} from "./packager-tool-5dzjsw5q.js";
 import {
   computeEntryPointSpec,
   createResourceBuilderServices,
   hasAnyTemplateRow,
   hasBareTemplateRow,
   readUipxProjects
-} from "./packager-tool-bkwnetqn.js";
+} from "./packager-tool-83rzavkx.js";
 import {
   toolsFactoryRepository
-} from "./packager-tool-nzghfa48.js";
+} from "./packager-tool-fv7xyzg2.js";
 import {
   catchError,
-  getFileSystem,
   logger
-} from "./packager-tool-0f0wt9vh.js";
+} from "./packager-tool-5fjp60dk.js";
+import {
+  getFileSystem
+} from "./packager-tool-zf3929se.js";
 
 // src/services/project-contributions.ts
 var ENTRY_POINT_RESOURCE_KIND = "process";
@@ -185,4 +187,4 @@ function isSameSpecValue(a, b) {
 
 export { ProjectContributionsError, collectProjectContributions, assertNoContributionErrors, contributionErrorMessages, applyProjectContributions };
 
-//# debugId=F82FA56EE24E69EE64756E2164756E21
+//# debugId=44C1EE84E4A52AC964756E2164756E21

package/dist/packager-tool-vmsxq1pc.js

@@ -0,0 +1,104 @@
+import {
+  catchError,
+  logger
+} from "./packager-tool-5fjp60dk.js";
+
+// ../solution-sdk/src/solution-file.ts
+var STUDIO_WEB_PROJECT_TYPE_OVERRIDES = {
+  ProcessOrchestration: "processOrchestration"
+};
+function normalizeProjectType(projectType) {
+  return STUDIO_WEB_PROJECT_TYPE_OVERRIDES[projectType] ?? projectType;
+}
+function toPortableRelativePath(relativePath) {
+  return relativePath.replace(/\\/g, "/");
+}
+async function readUipxFile(fs, solutionDir) {
+  const dirEntries = await fs.readdir(solutionDir);
+  const uipxFileName = dirEntries.find((f) => f.endsWith(".uipx"));
+  if (!uipxFileName) {
+    throw new Error(`No .uipx file found in ${solutionDir}. Run 'uip solution init' first.`);
+  }
+  const uipxContent = await fs.readFile(fs.path.join(solutionDir, uipxFileName), "utf-8");
+  if (!uipxContent) {
+    throw new Error(`Could not read .uipx file: ${uipxFileName} is empty or missing.`);
+  }
+  const [parseError, parsed] = catchError(() => JSON.parse(uipxContent));
+  if (parseError) {
+    throw new Error(`Invalid .uipx file: could not parse JSON in ${uipxFileName}.`);
+  }
+  const uipx = validateUipxFile(parsed, uipxFileName);
+  return { uipx, uipxFileName };
+}
+function validateUipxFile(parsed, uipxFileName) {
+  if (!isRecord(parsed)) {
+    throw new Error(`Invalid .uipx file: ${uipxFileName} must contain a JSON object.`);
+  }
+  if (typeof parsed.SolutionId !== "string" || !parsed.SolutionId.trim()) {
+    throw new Error("Invalid .uipx file: missing SolutionId.");
+  }
+  if (!Array.isArray(parsed.Projects) || parsed.Projects.length === 0) {
+    throw new Error("Invalid .uipx file: missing Projects.");
+  }
+  for (const [index, project] of parsed.Projects.entries()) {
+    if (!isRecord(project)) {
+      throw new Error(`Invalid .uipx file: Projects[${index}] must be an object.`);
+    }
+    if (typeof project.ProjectRelativePath !== "string" || !project.ProjectRelativePath.trim()) {
+      const pathHint = typeof project.Path === "string" ? " Found Path, but .uipx uses ProjectRelativePath." : "";
+      throw new Error(`Invalid .uipx file: Projects[${index}] is missing ProjectRelativePath.${pathHint} Use 'uip solution projects add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`);
+    }
+  }
+  return parsed;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveSolutionDir(fs, inputPath) {
+  const resolved = fs.path.resolve(inputPath);
+  if (resolved.endsWith(".uipx")) {
+    return fs.path.dirname(resolved);
+  }
+  return resolved;
+}
+async function updateUipxSolutionId(fs, uipxPath, newSolutionId) {
+  const [readError, content] = await catchError(fs.readFile(uipxPath, "utf-8"));
+  if (readError || !content) {
+    logger.error(`Could not read .uipx file for update: ${readError?.message ?? "empty file"}`);
+    return;
+  }
+  const [parseError, parsed] = catchError(() => JSON.parse(content));
+  if (parseError) {
+    logger.error(`Could not parse .uipx file for update: ${parseError.message}`);
+    return;
+  }
+  parsed.SolutionId = newSolutionId;
+  const [writeError] = await catchError(fs.writeFile(uipxPath, JSON.stringify(parsed, null, 4)));
+  if (writeError) {
+    logger.error(`Could not update .uipx with new SolutionId: ${writeError.message}`);
+  } else {
+    logger.info(`Updated .uipx with Studio Web SolutionId: ${newSolutionId}`);
+  }
+}
+async function findSolutionFileUpward(fs, startDir) {
+  let dir = startDir;
+  while (true) {
+    const entries = await fs.readdir(dir);
+    const files = entries.filter((f) => f.endsWith(".uipx"));
+    if (files.length === 1) {
+      return fs.path.join(dir, files[0]);
+    }
+    if (files.length > 1) {
+      throw new Error(`Multiple .uipx files found in ${dir}. Please specify which solution file to use.`);
+    }
+    const parent = fs.path.dirname(dir);
+    if (parent === dir) {
+      throw new Error(`No .uipx solution file found (searched from ${startDir} to filesystem root)`);
+    }
+    dir = parent;
+  }
+}
+
+export { normalizeProjectType, toPortableRelativePath, readUipxFile, resolveSolutionDir, updateUipxSolutionId, findSolutionFileUpward };
+
+//# debugId=FD084AD2795A138064756E2164756E21

package/dist/packager-tool-w6jr4638.js

@@ -0,0 +1,166 @@
+import {
+  SolutionDeploymentAction
+} from "./packager-tool-t12hj6pd.js";
+import {
+  catchError
+} from "./packager-tool-5fjp60dk.js";
+
+// src/services/deployment-state.ts
+function quoteForShell(name) {
+  return `'${name.replace(/'/g, "'\\''")}'`;
+}
+var RESOURCES_PAGE_SIZE = 50;
+var RESOURCES_MAX_PAGES = 10;
+async function readPendingResourcesAsync(api, deploymentKey, scope) {
+  const pending = [];
+  let complete = false;
+  for (let page = 0, skip = 0;page < RESOURCES_MAX_PAGES; page++) {
+    const [readError, result] = await catchError(api.deploymentsGetDeploymentResources({ deploymentKey, skip, take: RESOURCES_PAGE_SIZE }, scope));
+    if (readError || !result) {
+      return;
+    }
+    const values = result.values ?? [];
+    for (const resource of values) {
+      if (resource.requiresConfiguration) {
+        pending.push(toPendingResource(resource));
+      }
+    }
+    skip += values.length;
+    if (values.length < RESOURCES_PAGE_SIZE || typeof result.count === "number" && skip >= result.count) {
+      complete = true;
+      break;
+    }
+  }
+  if (!complete) {
+    return;
+  }
+  if (pending.length > 0) {
+    await attachActivationReasonsAsync(api, deploymentKey, pending, scope);
+  }
+  return pending;
+}
+function toPendingResource(resource) {
+  return {
+    key: resource.key,
+    name: resource.name,
+    kind: resource.kind,
+    type: resource.type
+  };
+}
+async function attachActivationReasonsAsync(api, deploymentKey, pending, scope) {
+  const [readError, validation] = await catchError(() => api.deploymentsGetValidationResult({
+    deploymentKey,
+    deploymentAction: SolutionDeploymentAction.Activate
+  }, scope));
+  if (readError || !validation) {
+    return;
+  }
+  const reasons = new Map;
+  for (const resource of validation.resourceValidationErrors ?? []) {
+    const texts = (resource.errors ?? []).map((error) => error.errorCode ? `[${error.errorCode}] ${error.text}` : error.text).filter(Boolean);
+    if (texts.length > 0) {
+      reasons.set(resourceIdentity(resource.name, resource.type), texts.join("; "));
+    }
+  }
+  for (const resource of pending) {
+    const reason = reasons.get(resourceIdentity(resource.name, resource.type));
+    if (reason) {
+      resource.reason = reason;
+    }
+  }
+}
+function resourceIdentity(name, type) {
+  return `${name}\x00${type ?? ""}`;
+}
+var MAX_LISTED_RESOURCES = 10;
+function formatPendingResources(resources) {
+  const described = resources.slice(0, MAX_LISTED_RESOURCES).map((resource) => {
+    const type = resource.type && resource.type !== resource.kind ? ` (${resource.type})` : "";
+    const reason = resource.reason ? `: ${resource.reason}` : "";
+    return `${resource.kind} '${resource.name}'${type}${reason}`;
+  }).join("; ");
+  const remaining = resources.length - MAX_LISTED_RESOURCES;
+  return remaining > 0 ? `${described}; and ${remaining} more` : described;
+}
+function activationNextSteps(deployment, pendingResources) {
+  const name = deployment.name;
+  const version = deployment.currentPackageVersion ?? deployment.packageVersion;
+  const installed = `Deployment '${name}' is installed${version ? ` at version ${version}` : ""}`;
+  switch (deployment.activationStatus) {
+    case "NeedsSetupToActivate": {
+      const steps = [
+        `${installed} but not live: it needs 'Setup activation' before it can be activated.`,
+        describePendingResources(pendingResources)
+      ];
+      steps.push(`Complete 'Setup activation' for '${name}' in Orchestrator (Tenant > Solutions > Deployments, open the deployment). The CLI has no command for this step on an existing deployment: 'uip solution deploy config link' applies only to a new 'deploy run', an upgrade takes no config file, and 'uip solution deploy activate' is refused until the setup is done.`);
+      return steps;
+    }
+    case "ReadyToActivate":
+    case "Inactive":
+      return [
+        `${installed} but inactive. Activate it with: uip solution deploy activate ${quoteForShell(name)}.`
+      ];
+    case "ActivationFailed":
+      return [
+        `Activation of '${name}' failed. Inspect the deployment in Orchestrator, then retry with: uip solution deploy activate ${quoteForShell(name)}.`
+      ];
+    default:
+      return;
+  }
+}
+function appendDeploymentStateInstructions(instructions, deployment, pendingResources, feedSelector = "") {
+  const steps = deployment ? explainRefusal(deployment, pendingResources, feedSelector) : undefined;
+  return steps ? `${instructions}
+${steps.join(`
+`)}` : instructions;
+}
+function explainRefusal(deployment, pendingResources, feedSelector = "") {
+  const explains = deployment.operationStatus === "Draft" || deployment.operationStatus === "Successful" && deployment.activationStatus === "NeedsSetupToActivate";
+  if (!explains) {
+    return;
+  }
+  const steps = deploymentNextSteps(deployment, pendingResources, feedSelector);
+  return steps && steps.length > 0 ? steps : undefined;
+}
+function needsPendingResources(deployment) {
+  return deployment.activationStatus === "NeedsSetupToActivate" || deployment.operationStatus === "Draft" && deployment.operation === "ActivationSetup";
+}
+function deploymentNextSteps(deployment, pendingResources, feedSelector = "") {
+  if (deployment.operationStatus === "Draft") {
+    const steps = [describeDraft(deployment, feedSelector)];
+    if (deployment.operation === "ActivationSetup") {
+      steps.push(describePendingResources(pendingResources));
+    }
+    return steps;
+  }
+  return activationNextSteps(deployment, pendingResources);
+}
+function describePendingResources(pendingResources) {
+  if (pendingResources === undefined) {
+    return "The CLI could not read which resources need configuration; the deployment's Resources tab in Orchestrator lists them.";
+  }
+  if (pendingResources.length === 0) {
+    return "The service lists no resource as needing configuration; the deployment's Resources tab in Orchestrator shows what it asks for.";
+  }
+  return `Resources that need configuration: ${formatPendingResources(pendingResources)}.`;
+}
+function describeDraft(deployment, feedSelector) {
+  const name = deployment.name;
+  const state = `(Operation: ${deployment.operation}, OperationStatus: Draft, ActivationStatus: ${deployment.activationStatus})`;
+  switch (deployment.operation) {
+    case "ActivationSetup":
+      return `Deployment '${name}' has a 'Setup activation' that was started but not completed ${state} and cannot be activated until it is. Finish it in Orchestrator (Tenant > Solutions > Deployments, open the deployment; the UI lists it as 'Activation setup / Draft'). The CLI has no command for this step on an existing deployment. To discard the unfinished setup instead, run: uip solution deploy delete ${quoteForShell(name)} --yes. That removes the draft alone; the deployment returns to its previous record, still waiting for setup.`;
+    case "VersionChange":
+      return `Deployment '${name}' has an upgrade that was queued but never installed ${state} and cannot be activated until it settles. 'uip solution deploy upgrade' installs the draft it queues; a draft left by another client stays until it is installed or removed; check it with: uip solution deploy list${feedSelector}.`;
+    case "Install":
+    case undefined:
+    case null:
+      return `Deployment '${name}' exists but is still in Draft state (OperationStatus: ${deployment.operationStatus}, ActivationStatus: ${deployment.activationStatus}). Draft deployments are created by deploy runs that did not complete successfully and cannot be activated. Fix the deploy run validation errors, rerun 'uip solution deploy run', then activate after 'uip solution deploy list${feedSelector}' shows the deployment is no longer Draft.`;
+    default:
+      return `Deployment '${name}' has a pending ${deployment.operation} ${state} and cannot be activated until it settles. Check it with: uip solution deploy list${feedSelector}.`;
+  }
+}
+
+export { quoteForShell, readPendingResourcesAsync, appendDeploymentStateInstructions, explainRefusal, needsPendingResources, deploymentNextSteps };
+
+//# debugId=ABAB11E889A49E7364756E2164756E21

package/dist/packager-tool-zf3929se.js

@@ -0,0 +1,237 @@
+import {
+  __require
+} from "./packager-tool-1de529jm.js";
+
+// ../filesystem/src/node.ts
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+var LOCK_HEARTBEAT_MS = 5000;
+var LOCK_STALE_MS = 15000;
+var LOCK_MAX_WAIT_MS = 20000;
+var LOCK_MAX_HOLD_MS = 60000;
+var LOCK_RETRY_MIN_MS = 100;
+var LOCK_RETRY_JITTER_MS = 200;
+
+class NodeFileSystem {
+  path = {
+    join: path.join,
+    resolve: path.resolve,
+    relative: path.relative,
+    dirname: path.dirname,
+    isAbsolute: path.isAbsolute,
+    basename: path.basename
+  };
+  env = {
+    cwd: process.cwd,
+    homedir: os.homedir,
+    tmpdir: os.tmpdir,
+    getenv: (key) => process.env[key]
+  };
+  utils = {
+    open: async (url) => {
+      const { default: open } = await import("./index-sby22td6.js");
+      await open(url);
+    }
+  };
+  async readFile(path2, options) {
+    try {
+      if (options) {
+        return await fs.readFile(path2, "utf-8");
+      }
+      return await fs.readFile(path2);
+    } catch (error) {
+      if (this.isEnoent(error))
+        return null;
+      throw error;
+    }
+  }
+  async writeFile(filePath, data) {
+    const dir = path.dirname(filePath);
+    if (dir) {
+      await fs.mkdir(dir, { recursive: true });
+    }
+    await fs.writeFile(filePath, data);
+  }
+  async appendFile(filePath, data) {
+    const dir = path.dirname(filePath);
+    if (dir) {
+      await fs.mkdir(dir, { recursive: true });
+    }
+    await fs.appendFile(filePath, data);
+  }
+  async readdir(dirPath) {
+    try {
+      return await fs.readdir(dirPath);
+    } catch (error) {
+      if (this.isEnoent(error))
+        return [];
+      throw error;
+    }
+  }
+  async stat(filePath) {
+    try {
+      const stats = await fs.stat(filePath);
+      return {
+        isFile: () => stats.isFile(),
+        isDirectory: () => stats.isDirectory(),
+        size: stats.size,
+        mtimeMs: stats.mtimeMs
+      };
+    } catch (error) {
+      if (this.isEnoent(error))
+        return null;
+      throw error;
+    }
+  }
+  async exists(filePath) {
+    return existsSync(filePath);
+  }
+  async mkdir(dirPath) {
+    await fs.mkdir(dirPath, { recursive: true });
+  }
+  async acquireLock(lockPath) {
+    const canonicalPath = await this.canonicalizeLockTarget(lockPath);
+    const lockFile = `${canonicalPath}.lock`;
+    const ownerId = randomUUID();
+    const start = Date.now();
+    while (true) {
+      try {
+        await fs.writeFile(lockFile, ownerId, { flag: "wx" });
+        return this.createLockRelease(lockFile, ownerId);
+      } catch (error) {
+        if (!this.hasErrnoCode(error, "EEXIST")) {
+          throw error;
+        }
+        const stats = await fs.stat(lockFile).catch(() => null);
+        if (stats && Date.now() - stats.mtimeMs > LOCK_STALE_MS) {
+          const reclaimed = await fs.rm(lockFile, { force: true }).then(() => true).catch(() => false);
+          if (reclaimed)
+            continue;
+        }
+        if (Date.now() - start > LOCK_MAX_WAIT_MS) {
+          throw new Error(`ELOCKED: timed out waiting for lock on ${canonicalPath}`);
+        }
+        await new Promise((resolve2) => setTimeout(resolve2, LOCK_RETRY_MIN_MS + Math.random() * LOCK_RETRY_JITTER_MS));
+      }
+    }
+  }
+  async canonicalizeLockTarget(lockPath) {
+    const absolute = path.resolve(lockPath);
+    const fullReal = await fs.realpath(absolute).catch(() => null);
+    if (fullReal)
+      return fullReal;
+    const parent = path.dirname(absolute);
+    const base = path.basename(absolute);
+    const canonicalParent = await fs.realpath(parent).catch(() => parent);
+    return path.join(canonicalParent, base);
+  }
+  createLockRelease(lockFile, ownerId) {
+    const heartbeatStart = Date.now();
+    let heartbeatTimer;
+    let stopped = false;
+    const stopHeartbeat = () => {
+      stopped = true;
+      if (heartbeatTimer)
+        clearTimeout(heartbeatTimer);
+    };
+    const scheduleNextHeartbeat = () => {
+      if (stopped)
+        return;
+      if (Date.now() - heartbeatStart >= LOCK_MAX_HOLD_MS) {
+        stopped = true;
+        return;
+      }
+      heartbeatTimer = setTimeout(() => {
+        runHeartbeat();
+      }, LOCK_HEARTBEAT_MS);
+      heartbeatTimer.unref?.();
+    };
+    const runHeartbeat = async () => {
+      if (stopped)
+        return;
+      const current = await fs.readFile(lockFile, "utf-8").catch(() => null);
+      if (stopped)
+        return;
+      if (current !== ownerId) {
+        stopped = true;
+        return;
+      }
+      const now = Date.now() / 1000;
+      await fs.utimes(lockFile, now, now).catch(() => {});
+      scheduleNextHeartbeat();
+    };
+    scheduleNextHeartbeat();
+    let released = false;
+    return async () => {
+      if (released)
+        return;
+      released = true;
+      stopHeartbeat();
+      const current = await fs.readFile(lockFile, "utf-8").catch(() => null);
+      if (current === ownerId) {
+        await fs.rm(lockFile, { force: true });
+      }
+    };
+  }
+  async rm(filePath) {
+    await fs.rm(filePath, { recursive: true, force: true });
+  }
+  async rename(oldPath, newPath) {
+    await fs.rename(oldPath, newPath);
+  }
+  async realpath(filePath) {
+    try {
+      return await fs.realpath(filePath);
+    } catch (error) {
+      if (this.isEnoent(error))
+        return filePath;
+      throw error;
+    }
+  }
+  async getTempDir() {
+    return await fs.mkdtemp(path.join(os.tmpdir(), "uipath-fs-"));
+  }
+  async copyDirectory(sourcePath, destPath) {
+    const sourceStats = await this.stat(sourcePath);
+    if (!sourceStats) {
+      throw new Error(`Source directory does not exist: ${sourcePath}`);
+    }
+    if (!sourceStats.isDirectory()) {
+      throw new Error(`Source path is not a directory: ${sourcePath}`);
+    }
+    await this.mkdir(destPath);
+    const entries = await this.readdir(sourcePath);
+    for (const entry of entries) {
+      const srcEntry = path.join(sourcePath, entry);
+      const destEntry = path.join(destPath, entry);
+      const entryStats = await this.stat(srcEntry);
+      if (!entryStats)
+        continue;
+      if (entryStats.isDirectory()) {
+        await this.copyDirectory(srcEntry, destEntry);
+      } else if (entryStats.isFile()) {
+        const content = await this.readFile(srcEntry);
+        if (content !== null) {
+          await this.writeFile(destEntry, content);
+        }
+      }
+    }
+  }
+  isEnoent(error) {
+    return this.hasErrnoCode(error, "ENOENT");
+  }
+  hasErrnoCode(error, code) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === code;
+  }
+}
+
+// ../filesystem/src/index.ts
+var fsInstance = new NodeFileSystem;
+var getFileSystem = () => fsInstance;
+
+export { NodeFileSystem, getFileSystem };
+
+//# debugId=E06D65CFBE49DC8C64756E2164756E21