@uipath/agent-tool 1.201.0 → 1.202.0-preview.136

package/dist/packager-tool-yv3rvyas.js

@@ -1,239 +0,0 @@
-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 setFileSystem = (_fs) => () => {};
-var getFileSystem = () => fsInstance;
-var getFileSystemAsync = async () => fsInstance;
-
-export { NodeFileSystem, setFileSystem, getFileSystem, getFileSystemAsync };
-
-//# debugId=3E49815A855BD0ED64756E2164756E21