@uipath/solution-tool 1.203.0-preview.212 → 1.204.0-preview.211

package/dist/{packager-tool-resolver-fmjr60x8.js → packager-tool-resolver-2cbxyq6k.js}

@@ -3,10 +3,11 @@ import {
   ensurePackagerTools,
   isUnpackableProjectTypeError,
   toolVerbForProjectType
-} from "./packager-tool-k4mskzww.js";
-import"./packager-tool-jz2wbfjz.js";
-import"./packager-tool-nzghfa48.js";
-import"./packager-tool-0f0wt9vh.js";
+} from "./packager-tool-5dzjsw5q.js";
+import"./packager-tool-zns6n8zp.js";
+import"./packager-tool-fv7xyzg2.js";
+import"./packager-tool-5fjp60dk.js";
+import"./packager-tool-zf3929se.js";
 import"./packager-tool-dfrk01gn.js";
 import"./packager-tool-1de529jm.js";
 export {
@@ -16,4 +17,4 @@ export {
   toolVerbForProjectType
 };
 
-//# debugId=E7AC0B5156657E9564756E2164756E21
+//# debugId=C6DDCB8627A7967264756E2164756E21

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-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