@wirecat/mail-cli 0.0.0-stage → 0.1.1

package/dist/bundle/chunk-75CWWETH.js

@@ -0,0 +1,379 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  CliError
+} from "./chunk-5BVIWP3S.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/files/ordinary-file.js
+import { constants } from "node:fs";
+import { lstat, open } from "node:fs/promises";
+var deviceOf = /* @__PURE__ */ __name((dev) => process.platform === "win32" ? BigInt.asUintN(32, dev) : dev, "deviceOf");
+var sameIdentity = /* @__PURE__ */ __name((left, right) => left.ino === right.ino && deviceOf(left.dev) === deviceOf(right.dev), "sameIdentity");
+var openOrdinaryFile = /* @__PURE__ */ __name(async (path, options = {}) => {
+  const before = await lstat(path, { bigint: true });
+  if (before.isSymbolicLink())
+    throw new CliError("validation_error", "archive path must be an ordinary file without a symlink");
+  if (!before.isFile())
+    throw new CliError("validation_error", "archive path must be an ordinary file");
+  const access = options.writable ? constants.O_RDWR : constants.O_RDONLY;
+  const flags = process.platform === "win32" ? access : access | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0);
+  const file = await open(path, flags);
+  try {
+    const opened = await file.stat({ bigint: true });
+    const after = await lstat(path, { bigint: true });
+    if (!opened.isFile() || !after.isFile() || before.ino !== opened.ino || before.ino !== after.ino)
+      throw new CliError("validation_error", "archive file changed while opening");
+    if (process.platform === "win32" && before.dev === 0n && after.dev === 0n) {
+      const witness = await open(path, flags);
+      try {
+        const identified = await witness.stat({ bigint: true });
+        const final = await lstat(path, { bigint: true });
+        if (opened.dev === 0n || !identified.isFile() || !final.isFile() || !sameIdentity(identified, opened) || final.ino !== before.ino || final.dev !== 0n && deviceOf(final.dev) !== deviceOf(opened.dev))
+          throw new CliError("validation_error", "archive file changed while opening");
+      } finally {
+        await witness.close();
+      }
+    } else if (deviceOf(before.dev) !== deviceOf(opened.dev) || deviceOf(before.dev) !== deviceOf(after.dev)) {
+      throw new CliError("validation_error", "archive file changed while opening");
+    }
+    return file;
+  } catch (error) {
+    await file.close();
+    throw error;
+  }
+}, "openOrdinaryFile");
+var sameOrdinaryFile = /* @__PURE__ */ __name(async (path, created) => {
+  let file;
+  try {
+    file = await openOrdinaryFile(path);
+  } catch (error) {
+    if (error instanceof CliError || typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT")
+      return false;
+    throw error;
+  }
+  try {
+    return sameIdentity(created, await file.stat({ bigint: true }));
+  } finally {
+    await file.close();
+  }
+}, "sameOrdinaryFile");
+var syncDirectory = /* @__PURE__ */ __name(async (path) => {
+  if (process.platform === "win32")
+    return;
+  const directory = await open(path, constants.O_RDONLY | (constants.O_DIRECTORY ?? 0) | (constants.O_NOFOLLOW ?? 0));
+  try {
+    if (!(await directory.stat()).isDirectory())
+      throw new CliError("validation_error", "archive publication directory must be ordinary");
+    await directory.sync();
+  } finally {
+    await directory.close();
+  }
+}, "syncDirectory");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/files/atomic-write.js
+import { randomUUID } from "node:crypto";
+import { constants as constants2 } from "node:fs";
+import { link, open as open2, realpath, rename, unlink } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+var openFolder = /* @__PURE__ */ __name((folder) => process.platform === "win32" ? Promise.resolve(void 0) : open2(folder, constants2.O_RDONLY | (constants2.O_DIRECTORY ?? 0) | (constants2.O_NOFOLLOW ?? 0)), "openFolder");
+var writeFileAtomic = /* @__PURE__ */ __name(async (path, content, { mode = 384, overwrite = true, signal, beforePublish } = {}) => {
+  signal?.throwIfAborted();
+  const folder = await realpath(dirname(path));
+  const target = join(folder, basename(path));
+  const directory = await openFolder(folder);
+  try {
+    const temporary = join(folder, `.${basename(path)}.${randomUUID()}.tmp`);
+    let handle = await open2(temporary, "wx", mode);
+    let published = false;
+    try {
+      await handle.writeFile(content);
+      await handle.sync();
+      await handle.close();
+      handle = void 0;
+      signal?.throwIfAborted();
+      await beforePublish?.();
+      if (overwrite)
+        await rename(temporary, target);
+      else
+        await link(temporary, target);
+      published = overwrite;
+      await directory?.sync();
+    } finally {
+      await handle?.close().catch(() => void 0);
+      if (!published)
+        await unlink(temporary).catch(() => void 0);
+    }
+  } finally {
+    await directory?.close().catch(() => void 0);
+  }
+}, "writeFileAtomic");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/files/bounded-utf8.js
+var readBoundedUtf8File = /* @__PURE__ */ __name(async (path, { maxBytes }) => {
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 1 || maxBytes > 16 * 1024 * 1024)
+    throw new CliError("validation_error", "file maxBytes takes 1\u201316777216 bytes");
+  const file = await openOrdinaryFile(path);
+  try {
+    if ((await file.stat()).size > maxBytes)
+      throw new CliError("validation_error", "input file exceeds its byte budget");
+    const chunks = [], buffer = Buffer.alloc(Math.min(65536, maxBytes + 1));
+    let bytes = 0;
+    for (; ; ) {
+      const { bytesRead } = await file.read(buffer, 0, Math.min(buffer.length, maxBytes - bytes + 1), null);
+      if (bytesRead === 0)
+        break;
+      bytes += bytesRead;
+      if (bytes > maxBytes)
+        throw new CliError("validation_error", "input file exceeds its byte budget");
+      chunks.push(Buffer.from(buffer.subarray(0, bytesRead)));
+    }
+    try {
+      return new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks, bytes));
+    } catch {
+      throw new CliError("validation_error", "input file must contain valid UTF-8");
+    }
+  } finally {
+    await file.close();
+  }
+}, "readBoundedUtf8File");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/files/lock.js
+import { mkdir as mkdir2 } from "node:fs/promises";
+import { basename as basename2, dirname as dirname2 } from "node:path";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/files/native-writer-lease.js
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { lstat as lstat3, mkdir, open as open3, realpath as realpath3, rmdir as rmdir2, unlink as unlink4 } from "node:fs/promises";
+import { hostname as hostname2 } from "node:os";
+import { join as join3 } from "node:path";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/files/native-lease-inspection.js
+import { lstat as lstat2, readdir, realpath as realpath2, unlink as unlink2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/files/native-lease-owner.js
+import { hostname } from "node:os";
+var missingLeaseFile = /* @__PURE__ */ __name((error) => typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT", "missingLeaseFile");
+var readLeaseOwner = /* @__PURE__ */ __name(async (path, name, signal) => {
+  signal?.throwIfAborted();
+  try {
+    const file = await openOrdinaryFile(path);
+    try {
+      if ((await file.stat()).size > 4096)
+        return null;
+      const buffer = Buffer.alloc(4097);
+      let size = 0;
+      while (size < buffer.length) {
+        signal?.throwIfAborted();
+        const { bytesRead } = await file.read(buffer, size, buffer.length - size, size);
+        if (bytesRead === 0)
+          break;
+        size += bytesRead;
+      }
+      signal?.throwIfAborted();
+      if (size > 4096)
+        return null;
+      const owner = JSON.parse(buffer.subarray(0, size).toString("utf8"));
+      if (owner?.version !== 1 || !Number.isSafeInteger(owner.pid) || owner.pid <= 0 || typeof owner.host !== "string" || !owner.host.trim() || !/^[a-f0-9-]{36}$/.test(owner.nonce) || name !== `${owner.pid}-${owner.nonce}.json`)
+        return null;
+      return owner;
+    } finally {
+      await file.close();
+    }
+  } catch {
+    signal?.throwIfAborted();
+    return null;
+  }
+}, "readLeaseOwner");
+var leaseOwnerStatus = /* @__PURE__ */ __name((owner) => {
+  if (owner.host !== hostname())
+    return "foreign";
+  try {
+    process.kill(owner.pid, 0);
+    return "active";
+  } catch (error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ESRCH" ? "stale" : "active";
+  }
+}, "leaseOwnerStatus");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/files/native-lease-inspection.js
+var leaseInspection = /* @__PURE__ */ __name((markerDirectory) => {
+  const inspect = /* @__PURE__ */ __name(async (destination, options = {}) => {
+    options.signal?.throwIfAborted();
+    const root = await realpath2(destination);
+    options.signal?.throwIfAborted();
+    const folder = join2(root, markerDirectory);
+    let names;
+    try {
+      if ((await lstat2(folder)).isSymbolicLink())
+        throw new Error("symlink");
+      names = await readdir(folder);
+    } catch (error) {
+      options.signal?.throwIfAborted();
+      if (missingLeaseFile(error))
+        return [];
+      throw new CliError("configuration_error", "archive lock directory could not be read");
+    }
+    options.signal?.throwIfAborted();
+    const result = [];
+    for (const name of names.sort()) {
+      options.signal?.throwIfAborted();
+      const owner = await readLeaseOwner(join2(folder, name), name, options.signal);
+      result.push({
+        name,
+        status: owner ? leaseOwnerStatus(owner) : "unrecognized",
+        pid: owner?.pid ?? null,
+        host: owner?.host ?? null
+      });
+    }
+    return result;
+  }, "inspect");
+  const recover = /* @__PURE__ */ __name(async (destination, options = {}) => {
+    options.signal?.throwIfAborted();
+    const root = await realpath2(destination);
+    const locks = await inspect(root, options);
+    const removed = [];
+    if (options.apply)
+      for (const lock of locks) {
+        options.signal?.throwIfAborted();
+        if (lock.status !== "stale")
+          continue;
+        const path = join2(root, markerDirectory, lock.name);
+        const owner = await readLeaseOwner(path, lock.name, options.signal);
+        if (!owner || leaseOwnerStatus(owner) !== "stale")
+          continue;
+        try {
+          await unlink2(path);
+          removed.push(lock.name);
+        } catch (error) {
+          if (!missingLeaseFile(error))
+            throw new CliError("configuration_error", "stale archive lock could not be removed");
+        }
+      }
+    return { locks, removed };
+  }, "recover");
+  return { inspect, recover };
+}, "leaseInspection");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/files/native-lease-release.js
+import { rmdir, unlink as unlink3 } from "node:fs/promises";
+var ownedNativeLease = /* @__PURE__ */ __name((path, name, owner, folder, identity) => {
+  let releasing;
+  const held = /* @__PURE__ */ __name(async () => {
+    if (!await sameOrdinaryFile(path, identity))
+      return false;
+    const current = await readLeaseOwner(path, name);
+    return current?.host === owner.host && current.pid === owner.pid && current.nonce === owner.nonce;
+  }, "held");
+  const release = /* @__PURE__ */ __name(async () => {
+    if (!await held())
+      throw new CliError("configuration_error", "owned archive lock changed before release");
+    await unlink3(path);
+    await rmdir(folder).catch(() => void 0);
+  }, "release");
+  return {
+    held,
+    release: /* @__PURE__ */ __name(() => releasing ??= release().catch((error) => {
+      releasing = void 0;
+      throw error;
+    }), "release")
+  };
+}, "ownedNativeLease");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/files/native-writer-lease.js
+var validName = /* @__PURE__ */ __name((value) => typeof value === "string" && value.length > 0 && value !== "." && value !== ".." && !/[\\/\0:]/.test(value), "validName");
+var nativeWriterLeaseStore = /* @__PURE__ */ __name((layout) => {
+  const { markerDirectory, legacyMarker } = layout;
+  if (!validName(markerDirectory) || legacyMarker !== void 0 && (!validName(legacyMarker) || legacyMarker === markerDirectory))
+    throw new CliError("validation_error", "archive lock layout requires distinct ordinary entry names");
+  const inspection = leaseInspection(markerDirectory);
+  return {
+    ...inspection,
+    acquire: /* @__PURE__ */ __name(async (destination, { signal } = {}) => {
+      signal?.throwIfAborted();
+      const root = await realpath3(destination);
+      signal?.throwIfAborted();
+      const folder = join3(root, markerDirectory);
+      const owner = { version: 1, pid: process.pid, host: hostname2(), nonce: randomUUID2() };
+      const name = `${owner.pid}-${owner.nonce}.json`;
+      const path = join3(folder, name);
+      const marker = /* @__PURE__ */ __name(async (attempt = 1) => {
+        await mkdir(folder, { recursive: true });
+        try {
+          if ((await lstat3(folder)).isSymbolicLink())
+            throw new CliError("validation_error", "archive lock directory must not be a symlink");
+          await inspection.recover(root, { apply: true, signal });
+          signal?.throwIfAborted();
+          return await open3(path, "wx", 384);
+        } catch (error) {
+          if (attempt < 5 && missingLeaseFile(error))
+            return marker(attempt + 1);
+          throw error;
+        }
+      }, "marker");
+      const file = await marker();
+      let retained = false;
+      let identity;
+      try {
+        identity = await file.stat({ bigint: true });
+        await file.writeFile(JSON.stringify(owner));
+        await file.sync();
+        await file.close();
+        signal?.throwIfAborted();
+        const inspected = await inspection.inspect(root, { signal });
+        const own = inspected.find((lock) => lock.name === name);
+        if (own?.status !== "active" || own.pid !== owner.pid || own.host !== owner.host)
+          throw new CliError("configuration_error", "archive writer lost its lock before acquisition");
+        const locks = inspected.filter((lock) => lock.name !== name);
+        if (locks.length)
+          return { status: "busy", locks };
+        if (legacyMarker) {
+          try {
+            await lstat3(join3(root, legacyMarker));
+            return { status: "legacy" };
+          } catch (error) {
+            if (!missingLeaseFile(error))
+              throw error;
+          }
+        }
+        signal?.throwIfAborted();
+        retained = true;
+        return { status: "acquired", lease: ownedNativeLease(path, name, owner, folder, identity) };
+      } finally {
+        await file.close().catch(() => void 0);
+        if (!retained) {
+          if (identity && await sameOrdinaryFile(path, identity))
+            await unlink4(path).catch(() => void 0);
+          await rmdir2(folder).catch(() => void 0);
+        }
+      }
+    }, "acquire")
+  };
+}, "nativeWriterLeaseStore");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/files/lock.js
+var acquireLock = /* @__PURE__ */ __name(async (path, { signal } = {}) => {
+  const folder = dirname2(path);
+  await mkdir2(folder, { recursive: true, mode: 448 });
+  const acquired = await nativeWriterLeaseStore({ markerDirectory: basename2(path) }).acquire(folder, {
+    ...signal ? { signal } : {}
+  });
+  if (acquired.status === "acquired")
+    return acquired.lease;
+  throw new CliError("validation_error", `${basename2(path)} is locked by another process`, {
+    reason: "file.locked",
+    ...acquired.status === "busy" ? { holders: acquired.locks } : {}
+  });
+}, "acquireLock");
+
+export {
+  writeFileAtomic,
+  openOrdinaryFile,
+  sameOrdinaryFile,
+  syncDirectory,
+  readBoundedUtf8File,
+  acquireLock
+};