opencode-swarm 7.164.6 → 7.164.8

package/dist/cli/index-ry16d01s.js

@@ -0,0 +1,107 @@
+// @bun
+// src/utils/filesystem-identity.ts
+import * as fsSync from "fs";
+import * as path from "path";
+var _internals = {
+  realpathSyncNative: fsSync.realpathSync.native,
+  realpathSync: fsSync.realpathSync,
+  lstatSync: fsSync.lstatSync,
+  platform: () => process.platform
+};
+function normalizeIdentityPath(resolved) {
+  const normalized = _internals.platform() === "win32" ? path.win32.normalize(resolved) : path.posix.normalize(resolved);
+  return _internals.platform() === "win32" ? normalized.replaceAll("\\", "/").toLowerCase() : normalized;
+}
+function canonicalExistingFilesystemPath(entryPath) {
+  if (typeof entryPath !== "string")
+    return null;
+  const resolvedInput = path.resolve(entryPath);
+  try {
+    return normalizeIdentityPath(_internals.realpathSyncNative(resolvedInput));
+  } catch {
+    try {
+      return normalizeIdentityPath(_internals.realpathSync(resolvedInput));
+    } catch {
+      return null;
+    }
+  }
+}
+function legacyCanonicalExistingFilesystemPath(entryPath) {
+  if (typeof entryPath !== "string")
+    return null;
+  try {
+    return normalizeIdentityPath(_internals.realpathSync(path.resolve(entryPath)));
+  } catch {
+    return null;
+  }
+}
+function appendLinkedAncestorWitnesses(witnesses, startPath) {
+  let probe = path.resolve(startPath);
+  for (let depth = 0;depth < 4096; depth++) {
+    const parent = path.dirname(probe);
+    if (parent === probe)
+      return;
+    probe = parent;
+    try {
+      if (!_internals.lstatSync(probe).isSymbolicLink())
+        continue;
+    } catch {
+      continue;
+    }
+    const canonical = canonicalExistingFilesystemPath(probe);
+    if (canonical !== null) {
+      witnesses.push({ lexicalPath: probe, canonicalPath: canonical });
+    }
+  }
+}
+function filesystemIdentityWitnesses(entryPath) {
+  const lexicalPath = path.resolve(entryPath);
+  const canonicalPath = canonicalExistingFilesystemPath(lexicalPath);
+  if (canonicalPath === null)
+    return [];
+  const witnesses = [{ lexicalPath, canonicalPath }];
+  appendLinkedAncestorWitnesses(witnesses, lexicalPath);
+  return witnesses;
+}
+function canonicalPathFromExistingAncestor(entryPath) {
+  let probe = path.resolve(entryPath);
+  const tail = [];
+  for (let depth = 0;depth < 4096; depth++) {
+    let stat;
+    try {
+      stat = _internals.lstatSync(probe);
+    } catch (error) {
+      const code = error && typeof error === "object" && "code" in error ? String(error.code) : undefined;
+      if (code !== "ENOENT" && code !== "ENOTDIR")
+        return null;
+      const parent = path.dirname(probe);
+      if (parent === probe)
+        return null;
+      tail.unshift(path.basename(probe));
+      probe = parent;
+      continue;
+    }
+    const canonicalAncestor = canonicalExistingFilesystemPath(probe);
+    if (canonicalAncestor === null)
+      return null;
+    let existingAncestorIsLink = false;
+    existingAncestorIsLink = stat.isSymbolicLink();
+    return {
+      canonicalPath: normalizeIdentityPath(path.join(canonicalAncestor, ...tail)),
+      existingAncestor: probe,
+      existingAncestorIsLink,
+      identityWitnesses: filesystemIdentityWitnesses(probe)
+    };
+  }
+  return null;
+}
+function canonicalPathForFutureIo(entryPath) {
+  return canonicalExistingFilesystemPath(entryPath) ?? canonicalPathFromExistingAncestor(entryPath)?.canonicalPath ?? null;
+}
+function sameExistingFilesystemPath(a, b) {
+  const canonicalA = canonicalExistingFilesystemPath(a);
+  const canonicalB = canonicalExistingFilesystemPath(b);
+  return canonicalA !== null && canonicalB !== null && canonicalA === canonicalB;
+}
+
+export { canonicalExistingFilesystemPath, legacyCanonicalExistingFilesystemPath, filesystemIdentityWitnesses, canonicalPathFromExistingAncestor, canonicalPathForFutureIo, sameExistingFilesystemPath };