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

package/dist/packager-tool-4pvh3k50.js

@@ -0,0 +1,265 @@
+import {
+  __require
+} from "./packager-tool-wckvcay0.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-hsadteg4.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-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