@uipath/solution-tool 1.200.0-preview.120 → 1.201.0-preview.121

package/dist/{packager-tool-1ps2qeqg.js → packager-tool-5arsyj36.js}

@@ -3,8 +3,9 @@ var UIPATH_HOME_DIR = ".uipath";
 var AUTH_FILENAME = ".auth";
 var DEFAULT_BASE_URL = "https://cloud.uipath.com";
 var DEFAULT_AUTH_TIMEOUT_MS = 5 * 60 * 1000;
+var AUTH_TIMEOUT_ERROR_CODE = "EAUTHTIMEOUT";
 var AUTH_CANCELLED_ERROR_CODE = "EAUTHCANCELLED";
 
-export { UIPATH_HOME_DIR, AUTH_FILENAME, DEFAULT_BASE_URL, DEFAULT_AUTH_TIMEOUT_MS, AUTH_CANCELLED_ERROR_CODE };
+export { UIPATH_HOME_DIR, AUTH_FILENAME, DEFAULT_BASE_URL, DEFAULT_AUTH_TIMEOUT_MS, AUTH_TIMEOUT_ERROR_CODE, AUTH_CANCELLED_ERROR_CODE };
 
-//# debugId=6DCB1840782D2B3E64756E2164756E21
+//# debugId=E98AE5255EE78AC164756E2164756E21

package/dist/{packager-tool-kfzzznjr.js → packager-tool-67ssxgph.js}

@@ -1,9 +1,9 @@
 import {
   catchError
-} from "./packager-tool-y4wacqkp.js";
+} from "./packager-tool-bcpknnr8.js";
 import {
   getFileSystem
-} from "./packager-tool-q90kqh83.js";
+} from "./packager-tool-7eva0peq.js";
 
 // src/services/solution-init-service.ts
 var AGENTS_FILENAME = "AGENTS.md";

package/dist/packager-tool-7eva0peq.js

@@ -0,0 +1,265 @@
+import {
+  __require
+} from "./packager-tool-0v6na3yp.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-w03qc9m8.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;
+
+// ../auth/src/catch-error.ts
+function isPromiseLike(value) {
+  return value !== null && typeof value === "object" && typeof value.then === "function";
+}
+function catchError(fnOrPromise) {
+  if (isPromiseLike(fnOrPromise)) {
+    return settlePromiseLike(fnOrPromise);
+  }
+  try {
+    const result = fnOrPromise();
+    if (isPromiseLike(result)) {
+      return settlePromiseLike(result);
+    }
+    return [undefined, result];
+  } catch (error) {
+    return [
+      error instanceof Error ? error : new Error(String(error)),
+      undefined
+    ];
+  }
+}
+function settlePromiseLike(thenable) {
+  return Promise.resolve(thenable).then((data) => [undefined, data]).catch((error) => [
+    error instanceof Error ? error : new Error(String(error)),
+    undefined
+  ]);
+}
+
+export { getFileSystem, catchError };
+
+//# debugId=7C969342331D7A5864756E2164756E21

package/dist/{packager-tool-r1hk3s30.js → packager-tool-95fz7yd0.js}

@@ -1,22 +1,26 @@
 import {
   Configuration,
-  Configuration1 as Configuration2,
-  PackagesApi,
   PipelinesApi,
   resolveFeedScope
-} from "./packager-tool-9j8d0ts5.js";
+} from "./packager-tool-va301fjh.js";
+import {
+  Configuration as Configuration2,
+  PackagesApi
+} from "./packager-tool-550smwcc.js";
+import {
+  getSolutionAuthContext
+} from "./packager-tool-fzwxq48d.js";
 import {
   PollOutcome,
   catchError,
   extractErrorDetails,
-  getSolutionAuthContext,
   logger,
   mapPollFailure,
   pollUntil
-} from "./packager-tool-y4wacqkp.js";
+} from "./packager-tool-bcpknnr8.js";
 import {
   getFileSystem
-} from "./packager-tool-q90kqh83.js";
+} from "./packager-tool-7eva0peq.js";
 import {
   strFromU8,
   strToU8,
@@ -95,6 +99,60 @@ var isVersionConflictError = (message, details) => {
   const errorText = `${message} ${details ?? ""}`;
   return VERSION_CONFLICT_PATTERNS.some((pattern) => pattern.test(errorText));
 };
+var HTTP_STATUS_PATTERNS = [
+  /^HTTP\s+(\d{3})(?::|\s|-|$)/i,
+  /["']httpStatus["']\s*:\s*(\d{3})\b/i,
+  /["']statusCode["']\s*:\s*(\d{3})\b/i,
+  /["']status["']\s*:\s*(\d{3})\b/i,
+  /\bhttpStatus\s*[:=]\s*(\d{3})\b/i,
+  /\bstatusCode\s*[:=]\s*(\d{3})\b/i
+];
+var ERROR_CODE_PATTERNS = [
+  /["']errorCode["']\s*:\s*["']([^"']+)["']/i,
+  /["']errorCode["']\s*:\s*(\d+)\b/i,
+  /\berrorCode\s*[:=]\s*["']?([A-Za-z0-9_.-]+)["']?/i,
+  /["']code["']\s*:\s*["']([^"']+)["']/i,
+  /["']code["']\s*:\s*(\d+)\b/i
+];
+function extractFirstPatternValue(text, patterns) {
+  if (!text)
+    return;
+  for (const pattern of patterns) {
+    const match = pattern.exec(text);
+    if (match?.[1])
+      return match[1];
+  }
+  return;
+}
+function extractUploadHttpStatus(message, details) {
+  const rawStatus = extractFirstPatternValue(message, HTTP_STATUS_PATTERNS) ?? extractFirstPatternValue(details, HTTP_STATUS_PATTERNS);
+  if (!rawStatus)
+    return;
+  const status = Number(rawStatus);
+  return Number.isInteger(status) && status >= 100 && status <= 599 ? status : undefined;
+}
+function extractUploadErrorCode(message, details) {
+  return extractFirstPatternValue(details, ERROR_CODE_PATTERNS) ?? extractFirstPatternValue(message, ERROR_CODE_PATTERNS);
+}
+function retryHintForUploadStatus(httpStatus) {
+  if (httpStatus === 400 || httpStatus === 409 || httpStatus === 422) {
+    return "RetryWillNotFix";
+  }
+  if (httpStatus === 408 || httpStatus === 429 || httpStatus !== undefined && httpStatus >= 500 && httpStatus < 600) {
+    return "RetryLater";
+  }
+  return;
+}
+function mergeUploadErrorContext(context, httpStatus, errorCode) {
+  if (!context && httpStatus === undefined && errorCode === undefined) {
+    return;
+  }
+  return {
+    ...context ?? {},
+    ...httpStatus !== undefined ? { httpStatus } : {},
+    ...errorCode !== undefined ? { errorCode } : {}
+  };
+}
 async function publishSolutionAsync(packagePath, options = {}) {
   const [authError, auth] = await catchError(getSolutionAuthContext({
     tenant: options.tenant,
@@ -299,9 +357,12 @@ async function publishToFeed(auth, fileBuffer, scope, options) {
 }
 async function mapUploadError(uploadError) {
   const { message, details, context, retry } = await extractErrorDetails(uploadError);
+  const httpStatus = context?.httpStatus ?? extractUploadHttpStatus(message, details);
+  const errorCode = context?.errorCode ?? extractUploadErrorCode(message, details);
+  const resolvedContext = mergeUploadErrorContext(context, httpStatus, errorCode);
+  const resolvedRetry = context?.httpStatus === undefined ? retryHintForUploadStatus(httpStatus) ?? retry : retry;
   const fetchCause = uploadError instanceof Error && uploadError.name === "FetchError" && uploadError.cause instanceof Error ? uploadError.cause : null;
   const surfacedMessage = fetchCause ? `Failed to upload package: ${fetchCause.message}` : message;
-  const httpStatus = context?.httpStatus;
   let reason = "upload_failed";
   if (isVersionConflictError(message, details)) {
     reason = "upload_version_conflict";
@@ -315,12 +376,12 @@ async function mapUploadError(uploadError) {
     reason,
     message: surfacedMessage,
     details,
-    errorCode: context?.errorCode,
-    retry,
-    context
+    errorCode,
+    retry: resolvedRetry,
+    context: resolvedContext
   };
 }
 
 export { publishSolutionAsync };
 
-//# debugId=696E04915672C64A64756E2164756E21
+//# debugId=F5A8606772C19F7264756E2164756E21

package/dist/{packager-tool-sdhdmkt8.js → packager-tool-9vehmnke.js}

@@ -1793,6 +1793,7 @@ class CodedAppStrategy {
     }
     const bindingsV2Path = Path.join(contentFolder, "bindings_v2.json");
     const bindingsCandidatePaths = [
+      Path.join(projectPath, "source", "bindings_v2.json"),
       Path.join(projectPath, "source", "bindings.json"),
       Path.join(projectPath, "bindings.json"),
       Path.join(projectPath, "bindings_v2.json")
@@ -2924,4 +2925,4 @@ function registerPackagerFactories() {
 
 export { Path, TemporaryStorageService, ZipService, I18nManager, translate, BuildConfiguration, LogLevel, LogMessage, TargetFramework, ToolErrorCodes, ToolResult, toolsFactoryRepository2 as toolsFactoryRepository, registerPackagerFactories };
 
-//# debugId=721052D57B911C2E64756E2164756E21
+//# debugId=D265E2C64CC7BFA064756E2164756E21