agentwheel 0.20.20 → 0.21.2

package/dist/chunk-BNIF3FUR.js

@@ -1,148 +0,0 @@
-#!/usr/bin/env node
-
-// src/utils/fs.ts
-import { createHash } from "crypto";
-import {
-  copyFile,
-  cp,
-  mkdir,
-  readdir,
-  readFile,
-  rename,
-  rm,
-  stat,
-  writeFile
-} from "fs/promises";
-import { dirname, join, relative } from "path";
-var IGNORED_ENTRY_NAMES = /* @__PURE__ */ new Set([".git", "node_modules", "__pycache__", ".DS_Store"]);
-var IGNORED_SUFFIXES = [".pyc", ".pyo"];
-async function pathExists(path) {
-  try {
-    await stat(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function removeOnFailure(path, run) {
-  try {
-    return await run();
-  } catch (error) {
-    await rm(path, { recursive: true, force: true });
-    throw error;
-  }
-}
-async function hashPath(path) {
-  const stats = await stat(path);
-  if (stats.isFile()) {
-    const content = await readFile(path);
-    return createHash("sha256").update("file\0").update(content).digest("hex");
-  }
-  if (!stats.isDirectory()) {
-    throw new Error(`Unsupported path kind: ${path}`);
-  }
-  const hash = createHash("sha256").update("dir\0");
-  const files = await listFiles(path);
-  for (const file of files) {
-    hash.update(relative(path, file).replaceAll("\\", "/")).update("\0");
-    hash.update(await hashPath(file)).update("\0");
-  }
-  return hash.digest("hex");
-}
-async function listFiles(root) {
-  const out = [];
-  async function walk(dir) {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-      if (isIgnoredGeneratedEntry(entry.name)) continue;
-      const full = join(dir, entry.name);
-      if (entry.isDirectory()) {
-        await walk(full);
-      } else if (entry.isFile()) {
-        out.push(full);
-      }
-    }
-  }
-  await walk(root);
-  return out;
-}
-function isIgnoredGeneratedEntry(name) {
-  return IGNORED_ENTRY_NAMES.has(name) || IGNORED_SUFFIXES.some((suffix) => name.endsWith(suffix));
-}
-async function atomicCopy(source, dest, kind) {
-  await mkdir(dirname(dest), { recursive: true });
-  const temp = `${dest}.agentwheel-tmp-${process.pid}-${Date.now()}`;
-  await rm(temp, { recursive: true, force: true });
-  if (kind === "file") {
-    await copyFile(source, temp);
-  } else {
-    await cp(source, temp, { recursive: true, dereference: true, filter: (path) => !isIgnoredGeneratedEntry(path.split(/[\\/]/).at(-1) ?? "") });
-  }
-  await rm(dest, { recursive: true, force: true });
-  await rename(temp, dest);
-}
-async function writeJsonAtomic(path, data) {
-  await mkdir(dirname(path), { recursive: true });
-  const temp = `${path}.tmp-${process.pid}-${Date.now()}`;
-  await writeFile(temp, `${JSON.stringify(data, null, 2)}
-`, "utf8");
-  await rename(temp, path);
-}
-async function withFilesystemLock(lockPath, timeoutMs, fn, description = "cache") {
-  await mkdir(dirname(lockPath), { recursive: true });
-  const started = Date.now();
-  while (true) {
-    try {
-      await mkdir(lockPath);
-      await writeFile(join(lockPath, "owner.json"), JSON.stringify({ pid: process.pid, createdAt: (/* @__PURE__ */ new Date()).toISOString() }), "utf8");
-      break;
-    } catch (error) {
-      if (!isAlreadyExists(error)) throw error;
-      if (await removeStaleFilesystemLock(lockPath)) continue;
-      if (Date.now() - started > timeoutMs) {
-        throw new Error(`Timed out waiting for ${description} lock at ${lockPath}`);
-      }
-      await new Promise((resolve) => setTimeout(resolve, 50));
-    }
-  }
-  try {
-    return await fn();
-  } finally {
-    await rm(lockPath, { recursive: true, force: true });
-  }
-}
-async function removeStaleFilesystemLock(lockPath) {
-  try {
-    const owner = JSON.parse(await readFile(join(lockPath, "owner.json"), "utf8"));
-    if (typeof owner.pid !== "number" || !Number.isSafeInteger(owner.pid) || owner.pid <= 0 || isProcessAlive(owner.pid)) return false;
-    const stalePath = `${lockPath}.stale-${process.pid}-${Date.now()}`;
-    await rename(lockPath, stalePath);
-    await rm(stalePath, { recursive: true, force: true });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return typeof error === "object" && error !== null && "code" in error && error.code !== "ESRCH";
-  }
-}
-function isAlreadyExists(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
-}
-
-export {
-  pathExists,
-  removeOnFailure,
-  hashPath,
-  listFiles,
-  isIgnoredGeneratedEntry,
-  atomicCopy,
-  writeJsonAtomic,
-  withFilesystemLock,
-  isAlreadyExists
-};