screw-up 0.12.0 → 0.14.0

package/dist/main.js

@@ -0,0 +1,1165 @@
+#!/usr/bin/env node
+/*!
+ * name: screw-up
+ * version: 0.14.0
+ * description: Simply package metadata inserter on Vite plugin
+ * author: Kouji Matsui (@kekyo@mi.kekyo.net)
+ * license: MIT
+ * repository.url: https://github.com/kekyo/screw-up.git
+ * git.commit.hash: f1871df4c43aee9ab389a6ab1b2769b32322793b
+ */
+import { join, dirname, resolve } from "path";
+import { createWriteStream, createReadStream, existsSync } from "fs";
+import { mkdir, writeFile, stat, readdir, mkdtemp, copyFile, rm } from "fs/promises";
+import { spawn } from "child_process";
+import { Readable } from "stream";
+import { createGunzip, createGzip } from "zlib";
+import { pipeline } from "stream/promises";
+import { tmpdir } from "os";
+import { a as resolveRawPackageJsonObject, f as findWorkspaceRoot, b as collectWorkspaceSiblings, d as replacePeerDependenciesWildcards, c as createConsoleLogger } from "./internal-BgCvktPU.js";
+/*!
+ * name: tar-vern
+ * version: 1.2.0
+ * description: Tape archiver library for Typescript
+ * author: Kouji Matsui (@kekyo@mi.kekyo.net)
+ * license: MIT
+ * repository.url: https://github.com/kekyo/tar-vern.git
+ * git.commit.hash: 26ff2d96bfbd226ff79106604ff5f9e5193f91bc
+ */
+const MAX_NAME = 100;
+const MAX_PREFIX = 155;
+const getUName = (candidateName, candidateId, reflectStat) => {
+  return candidateName != null ? candidateName : reflectStat === "all" ? candidateId.toString() : "root";
+};
+const getBuffer = (data) => {
+  return Buffer.isBuffer(data) ? data : Buffer.from(data, "utf8");
+};
+const createDirectoryItem = async (path, reflectStat, options, signal) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const rs = reflectStat;
+  if (options == null ? void 0 : options.directoryPath) {
+    const stats = await stat(options.directoryPath);
+    const mode = (_a = options == null ? void 0 : options.mode) != null ? _a : stats.mode;
+    const uid = (_b = options == null ? void 0 : options.uid) != null ? _b : stats.uid;
+    const gid = (_c = options == null ? void 0 : options.gid) != null ? _c : stats.gid;
+    const date = (_d = options == null ? void 0 : options.date) != null ? _d : stats.mtime;
+    const uname = getUName(options == null ? void 0 : options.uname, stats.uid, rs);
+    const gname = getUName(options == null ? void 0 : options.gname, stats.gid, rs);
+    return {
+      kind: "directory",
+      path,
+      mode,
+      uname,
+      gname,
+      uid,
+      gid,
+      date
+    };
+  } else {
+    const mode = (_e = options == null ? void 0 : options.mode) != null ? _e : 493;
+    const uid = (_f = options == null ? void 0 : options.uid) != null ? _f : 0;
+    const gid = (_g = options == null ? void 0 : options.gid) != null ? _g : 0;
+    const date = (_h = options == null ? void 0 : options.date) != null ? _h : /* @__PURE__ */ new Date();
+    const uname = getUName(options == null ? void 0 : options.uname, void 0, rs);
+    const gname = getUName(options == null ? void 0 : options.gname, void 0, rs);
+    return {
+      kind: "directory",
+      path,
+      mode,
+      uname,
+      gname,
+      uid,
+      gid,
+      date
+    };
+  }
+};
+const createReadableFileItem = async (path, readable, options, signal) => {
+  var _a, _b, _c, _d, _e, _f;
+  const mode = (_a = options == null ? void 0 : options.mode) != null ? _a : 420;
+  const uid = (_b = options == null ? void 0 : options.uid) != null ? _b : 0;
+  const gid = (_c = options == null ? void 0 : options.gid) != null ? _c : 0;
+  const date = (_d = options == null ? void 0 : options.date) != null ? _d : /* @__PURE__ */ new Date();
+  const uname = (_e = options == null ? void 0 : options.uname) != null ? _e : "root";
+  const gname = (_f = options == null ? void 0 : options.gname) != null ? _f : "root";
+  let length = options == null ? void 0 : options.length;
+  if (!length) {
+    const chunks = [];
+    length = 0;
+    for await (const chunk of readable) {
+      const buffer = getBuffer(chunk);
+      chunks.push(buffer);
+      length += buffer.length;
+    }
+    return {
+      kind: "file",
+      path,
+      mode,
+      uname,
+      gname,
+      uid,
+      gid,
+      date,
+      content: {
+        kind: "readable",
+        length,
+        readable: Readable.from(chunks, { signal })
+      }
+    };
+  } else {
+    return {
+      kind: "file",
+      path,
+      mode,
+      uname,
+      gname,
+      uid,
+      gid,
+      date,
+      content: {
+        kind: "readable",
+        length,
+        readable
+      }
+    };
+  }
+};
+const createReadFileItem = async (path, filePath, reflectStat, options, signal) => {
+  const rs = reflectStat;
+  const stats = await stat(filePath);
+  const reader = createReadStream(filePath, { signal });
+  const mode = stats.mode;
+  const uid = stats.uid;
+  const gid = stats.gid;
+  const date = stats.mtime;
+  const uname = getUName(options == null ? void 0 : options.uname, stats.uid, rs);
+  const gname = getUName(options == null ? void 0 : options.gname, stats.gid, rs);
+  return await createReadableFileItem(path, reader, {
+    length: stats.size,
+    mode,
+    uname,
+    gname,
+    uid,
+    gid,
+    date
+  }, signal);
+};
+const storeReaderToFile = async (reader, path, signal) => {
+  const writer = createWriteStream(path, { signal });
+  await pipeline(reader, writer, { signal });
+};
+const getAllFilesInDirectory = async (baseDir, signal) => {
+  const collectFiles = async (currentDir, relativePath) => {
+    try {
+      const entries = await readdir(currentDir, { withFileTypes: true });
+      const result = [];
+      const tasks = entries.map(async (entry) => {
+        signal == null ? void 0 : signal.throwIfAborted();
+        const entryRelativePath = join(relativePath, entry.name);
+        if (entry.isDirectory()) {
+          const entryFullPath = join(currentDir, entry.name);
+          const directoryContents = await collectFiles(entryFullPath, entryRelativePath);
+          return [entryRelativePath, ...directoryContents];
+        } else {
+          return [entryRelativePath];
+        }
+      });
+      const allResults = await Promise.all(tasks);
+      for (const entryResults of allResults) {
+        result.push(...entryResults);
+      }
+      return result;
+    } catch (error) {
+      console.warn(`Warning: Could not read directory ${currentDir}:`, error);
+      return [];
+    }
+  };
+  return await collectFiles(baseDir, "");
+};
+const createEntryItemGenerator = async function* (baseDir, relativePaths, includeDirectory, reflectStat, signal) {
+  const rs = "exceptName";
+  const includeDir = true;
+  const pathsToProcess = await getAllFilesInDirectory(baseDir, signal);
+  for (const relativePath of pathsToProcess) {
+    const fsPath = join(baseDir, relativePath);
+    try {
+      signal == null ? void 0 : signal.throwIfAborted();
+      const stats = await stat(fsPath);
+      if (includeDir && stats.isDirectory()) {
+        yield await createDirectoryItem(relativePath, rs, {
+          directoryPath: fsPath
+        }, signal);
+      } else if (stats.isFile()) {
+        yield await createReadFileItem(relativePath, fsPath, rs, void 0, signal);
+      }
+    } catch (error) {
+      console.warn(`Warning: Could not access ${fsPath}:`, error);
+      continue;
+    }
+  }
+};
+const extractTo = async (iterator, basePath, signal) => {
+  for await (const entry of iterator) {
+    const targetPath = join(basePath, entry.path);
+    if (entry.kind === "directory") {
+      try {
+        signal == null ? void 0 : signal.throwIfAborted();
+        await mkdir(targetPath, { recursive: true, mode: entry.mode });
+      } catch (error) {
+        if (error.code !== "EEXIST") {
+          throw error;
+        }
+      }
+    } else if (entry.kind === "file") {
+      const parentDir = dirname(targetPath);
+      await mkdir(parentDir, { recursive: true });
+      const fileEntry = entry;
+      const content = await fileEntry.getContent("buffer");
+      await writeFile(targetPath, content, { mode: entry.mode, signal });
+    }
+  }
+};
+const utf8ByteLength = (str) => {
+  return Buffer.byteLength(str, "utf8");
+};
+const truncateUtf8Safe = (str, maxBytes) => {
+  let total = 0;
+  let i = 0;
+  while (i < str.length) {
+    const codePoint = str.codePointAt(i);
+    const char = String.fromCodePoint(codePoint);
+    const charBytes = Buffer.byteLength(char, "utf8");
+    if (total + charBytes > maxBytes) break;
+    total += charBytes;
+    i += char.length;
+  }
+  return str.slice(0, i);
+};
+const splitPath = (path) => {
+  var _a;
+  if (utf8ByteLength(path) <= MAX_NAME) {
+    return { prefix: "", name: path };
+  }
+  const parts = path.split("/");
+  let name = (_a = parts.pop()) != null ? _a : "";
+  let prefix = parts.join("/");
+  if (utf8ByteLength(name) > MAX_NAME) {
+    name = truncateUtf8Safe(name, MAX_NAME);
+  }
+  while (utf8ByteLength(prefix) > MAX_PREFIX) {
+    prefix = truncateUtf8Safe(prefix, MAX_PREFIX);
+  }
+  return { prefix, name };
+};
+const getOctalBytes = (value, length) => {
+  const str = value.toString(8).padStart(length - 1, "0") + "\0";
+  return Buffer.from(str, "ascii");
+};
+const getPaddedBytes = (buffer) => {
+  const extra = buffer.length % 512;
+  if (extra === 0) {
+    return buffer;
+  } else {
+    return Buffer.concat([buffer, Buffer.alloc(512 - extra, 0)]);
+  }
+};
+const terminatorBytes = Buffer.alloc(1024, 0);
+const createTarHeader = (type, path, size, mode, uname, gname, uid, gid, date) => {
+  const buffer = Buffer.alloc(512, 0);
+  const { name, prefix } = splitPath(path);
+  buffer.write(name, 0, 100, "utf8");
+  getOctalBytes(mode & 4095, 8).copy(buffer, 100);
+  getOctalBytes(uid, 8).copy(buffer, 108);
+  getOctalBytes(gid, 8).copy(buffer, 116);
+  getOctalBytes(size, 12).copy(buffer, 124);
+  getOctalBytes(Math.floor(date.getTime() / 1e3), 12).copy(buffer, 136);
+  Buffer.from("        ", "ascii").copy(buffer, 148);
+  if (type === "file") {
+    buffer.write("0", 156, 1, "ascii");
+  } else {
+    buffer.write("5", 156, 1, "ascii");
+  }
+  buffer.write("ustar\0", 257, 6, "ascii");
+  buffer.write("00", 263, 2, "ascii");
+  buffer.write(uname, 265, 32, "utf8");
+  buffer.write(gname, 297, 32, "utf8");
+  buffer.write(prefix, 345, 155, "utf8");
+  let sum = 0;
+  for (let i = 0; i < 512; i++) {
+    sum += buffer[i];
+  }
+  getOctalBytes(sum, 8).copy(buffer, 148);
+  return buffer;
+};
+const createTarPacker = (entryItemGenerator, compressionType, signal) => {
+  const entryItemIterator = async function* () {
+    for await (const entryItem of entryItemGenerator) {
+      switch (entryItem.kind) {
+        // Entry is a file
+        case "file": {
+          const entryItemContent = entryItem.content;
+          if (typeof entryItemContent === "string" || Buffer.isBuffer(entryItemContent)) {
+            const contentBytes = getBuffer(entryItemContent);
+            const tarHeaderBytes = createTarHeader(
+              "file",
+              entryItem.path,
+              contentBytes.length,
+              entryItem.mode,
+              entryItem.uname,
+              entryItem.gname,
+              entryItem.uid,
+              entryItem.gid,
+              entryItem.date
+            );
+            yield tarHeaderBytes;
+            const totalPaddedContentBytes = getPaddedBytes(contentBytes);
+            yield totalPaddedContentBytes;
+          } else {
+            const content = entryItemContent;
+            const tarHeaderBytes = createTarHeader(
+              "file",
+              entryItem.path,
+              content.length,
+              entryItem.mode,
+              entryItem.uname,
+              entryItem.gname,
+              entryItem.uid,
+              entryItem.gid,
+              entryItem.date
+            );
+            yield tarHeaderBytes;
+            let position = 0;
+            switch (content.kind) {
+              // Content is a generator
+              case "generator": {
+                for await (const contentBytes of content.generator) {
+                  yield contentBytes;
+                  position += contentBytes.length;
+                }
+                break;
+              }
+              // Content is a readable stream
+              case "readable": {
+                for await (const chunk of content.readable) {
+                  const contentBytes = getBuffer(chunk);
+                  yield contentBytes;
+                  position += contentBytes.length;
+                }
+                break;
+              }
+            }
+            if (position % 512 !== 0) {
+              yield Buffer.alloc(512 - position % 512, 0);
+            }
+          }
+          break;
+        }
+        // Entry is a directory
+        case "directory": {
+          const tarHeaderBytes = createTarHeader(
+            "directory",
+            entryItem.path,
+            0,
+            entryItem.mode,
+            entryItem.uname,
+            entryItem.gname,
+            entryItem.uid,
+            entryItem.gid,
+            entryItem.date
+          );
+          yield tarHeaderBytes;
+          break;
+        }
+      }
+    }
+    yield terminatorBytes;
+  };
+  const ct = compressionType;
+  switch (ct) {
+    // No compression
+    case "none": {
+      return Readable.from(entryItemIterator(), { signal });
+    }
+    // Gzip compression
+    case "gzip": {
+      const gzipStream = createGzip({ level: 9 });
+      const entryItemStream = Readable.from(entryItemIterator(), { signal });
+      entryItemStream.pipe(gzipStream);
+      return gzipStream;
+    }
+  }
+};
+const parseOctalBytes = (buffer, offset, length) => {
+  const str = buffer.subarray(offset, offset + length).toString("ascii").replace(/\0/g, "").trim();
+  return str ? parseInt(str, 8) : 0;
+};
+const parseString = (buffer, offset, length) => {
+  return buffer.subarray(offset, offset + length).toString("utf8").replace(/\0/g, "").trim();
+};
+const readExactBytes = async (iterator, size, signal) => {
+  var _a;
+  const chunks = [];
+  let totalRead = 0;
+  while (totalRead < size) {
+    const { value, done } = await iterator.next();
+    if (done) {
+      if (totalRead === 0) {
+        return void 0;
+      } else {
+        throw new Error(`Unexpected end of stream: expected ${size} bytes, got ${totalRead} bytes`);
+      }
+    }
+    const chunk = getBuffer(value);
+    const needed = size - totalRead;
+    if (chunk.length <= needed) {
+      chunks.push(chunk);
+      totalRead += chunk.length;
+    } else {
+      chunks.push(chunk.subarray(0, needed));
+      await ((_a = iterator.return) == null ? void 0 : _a.call(iterator, chunk.subarray(needed)));
+      totalRead = size;
+    }
+  }
+  return Buffer.concat(chunks, size);
+};
+const skipExactBytes = async (iterator, size, signal) => {
+  var _a;
+  let totalSkipped = 0;
+  while (totalSkipped < size) {
+    const { value, done } = await iterator.next();
+    if (done) {
+      throw new Error(`Unexpected end of stream: expected to skip ${size} bytes, skipped ${totalSkipped} bytes`);
+    }
+    const chunk = getBuffer(value);
+    const needed = size - totalSkipped;
+    if (chunk.length <= needed) {
+      totalSkipped += chunk.length;
+    } else {
+      await ((_a = iterator.return) == null ? void 0 : _a.call(iterator, chunk.subarray(needed)));
+      totalSkipped = size;
+    }
+  }
+};
+const skipPaddingBytesTo512Boundary = async (iterator, contentSize, signal) => {
+  const padding = (512 - contentSize % 512) % 512;
+  if (padding > 0) {
+    await skipExactBytes(iterator, padding);
+  }
+};
+const parseTarHeader = (buffer) => {
+  if (buffer.every((b) => b === 0)) {
+    return void 0;
+  }
+  const name = parseString(buffer, 0, 100);
+  const mode = parseOctalBytes(buffer, 100, 8);
+  const uid = parseOctalBytes(buffer, 108, 8);
+  const gid = parseOctalBytes(buffer, 116, 8);
+  const size = parseOctalBytes(buffer, 124, 12);
+  const mtime = new Date(parseOctalBytes(buffer, 136, 12) * 1e3);
+  const checksum = parseOctalBytes(buffer, 148, 8);
+  const typeflag = parseString(buffer, 156, 1);
+  const magic = parseString(buffer, 257, 6);
+  const uname = parseString(buffer, 265, 32);
+  const gname = parseString(buffer, 297, 32);
+  const prefix = parseString(buffer, 345, 155);
+  if (magic !== "ustar") {
+    throw new Error(`Invalid tar format: magic="${magic}"`);
+  }
+  let calculatedSum = 0;
+  for (let i = 0; i < 512; i++) {
+    if (i >= 148 && i < 156) {
+      calculatedSum += 32;
+    } else {
+      calculatedSum += buffer[i];
+    }
+  }
+  if (calculatedSum !== checksum) {
+    throw new Error(`Invalid checksum: expected ${checksum}, got ${calculatedSum}`);
+  }
+  let path = prefix ? `${prefix}/${name}` : name;
+  if (path.endsWith("/")) {
+    path = path.slice(0, -1);
+  }
+  const kind = typeflag === "5" ? "directory" : "file";
+  return {
+    kind,
+    path,
+    size,
+    mode,
+    uid,
+    gid,
+    mtime,
+    uname: uname || uid.toString(),
+    gname: gname || gid.toString(),
+    checksum,
+    consumed: false
+  };
+};
+const createBufferedAsyncIterator = (iterable, signal) => {
+  const buffer = [];
+  const iterator = iterable[Symbol.asyncIterator]();
+  return {
+    next: async () => {
+      if (buffer.length > 0) {
+        return { value: buffer.shift(), done: false };
+      }
+      return iterator.next();
+    },
+    return: async (value) => {
+      if (value !== void 0) {
+        buffer.unshift(value);
+      }
+      return { value: void 0, done: false };
+    }
+  };
+};
+const createReadableFromIterator = (iterator, size, signal, consumedRef) => {
+  const generator = async function* () {
+    var _a;
+    let remainingBytes = size;
+    while (remainingBytes > 0) {
+      const { value, done } = await iterator.next();
+      if (done) {
+        throw new Error(`Unexpected end of stream: expected ${size} bytes, remaining ${remainingBytes} bytes`);
+      }
+      const chunk = getBuffer(value);
+      if (chunk.length <= remainingBytes) {
+        remainingBytes -= chunk.length;
+        yield chunk;
+      } else {
+        const needed = chunk.subarray(0, remainingBytes);
+        const excess = chunk.subarray(remainingBytes);
+        remainingBytes = 0;
+        await ((_a = iterator.return) == null ? void 0 : _a.call(iterator, excess));
+        yield needed;
+        break;
+      }
+    }
+    await skipPaddingBytesTo512Boundary(iterator, size);
+    consumedRef.consumed = true;
+  };
+  return Readable.from(generator(), { signal });
+};
+const createTarExtractor = async function* (readable, compressionType, signal) {
+  const ct = compressionType;
+  let inputStream;
+  switch (ct) {
+    case "gzip":
+      const gunzip = createGunzip();
+      readable.pipe(gunzip);
+      inputStream = gunzip;
+      break;
+    case "none":
+    default:
+      inputStream = readable;
+      break;
+  }
+  const iterator = createBufferedAsyncIterator(inputStream);
+  let header;
+  while (true) {
+    if ((header == null ? void 0 : header.kind) === "file" && !header.consumed) {
+      await skipExactBytes(iterator, header.size);
+      await skipPaddingBytesTo512Boundary(iterator, header.size);
+      header.consumed = true;
+    }
+    let headerBuffer;
+    try {
+      headerBuffer = await readExactBytes(iterator, 512, signal);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("Unexpected end of stream")) {
+        throw new Error("Invalid tar format: incomplete header");
+      }
+      throw error;
+    }
+    if (headerBuffer === void 0) {
+      break;
+    }
+    header = parseTarHeader(headerBuffer);
+    if (!header) {
+      const secondBlock = await readExactBytes(iterator, 512);
+      if (secondBlock === void 0 || secondBlock.every((b) => b === 0)) {
+        break;
+      }
+      throw new Error("Invalid tar format: expected terminator block");
+    }
+    if (header.kind === "directory") {
+      yield {
+        kind: "directory",
+        path: header.path,
+        mode: header.mode,
+        uid: header.uid,
+        gid: header.gid,
+        uname: header.uname,
+        gname: header.gname,
+        date: header.mtime
+      };
+    } else {
+      const currentHeader = header;
+      yield {
+        kind: "file",
+        path: currentHeader.path,
+        mode: currentHeader.mode,
+        uid: currentHeader.uid,
+        gid: currentHeader.gid,
+        uname: currentHeader.uname,
+        gname: currentHeader.gname,
+        date: currentHeader.mtime,
+        getContent: async (type) => {
+          if (currentHeader.consumed) {
+            throw new Error("Content has already been consumed. Multiple calls to getContent are not supported.");
+          }
+          switch (type) {
+            // For string
+            case "string": {
+              const dataBuffer = await readExactBytes(iterator, currentHeader.size);
+              if (dataBuffer === void 0) {
+                throw new Error(`Unexpected end of stream while reading file data for ${currentHeader.path}`);
+              }
+              await skipPaddingBytesTo512Boundary(iterator, currentHeader.size);
+              currentHeader.consumed = true;
+              return dataBuffer.toString("utf8");
+            }
+            // For buffer
+            case "buffer": {
+              const dataBuffer = await readExactBytes(iterator, currentHeader.size);
+              if (dataBuffer === void 0) {
+                throw new Error(`Unexpected end of stream while reading file data for ${currentHeader.path}`);
+              }
+              await skipPaddingBytesTo512Boundary(iterator, currentHeader.size);
+              currentHeader.consumed = true;
+              return dataBuffer;
+            }
+            // For Readble stream
+            case "readable": {
+              const readable2 = createReadableFromIterator(iterator, currentHeader.size, signal, currentHeader);
+              return readable2;
+            }
+            default:
+              throw new Error(`Unsupported content type: ${type}`);
+          }
+        }
+      };
+    }
+  }
+};
+const runNpmPack = async (targetDir, packDestDir) => {
+  return new Promise((res, rej) => {
+    const npmProcess = spawn("npm", ["pack", "--pack-destination", packDestDir], {
+      cwd: targetDir,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    npmProcess.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    npmProcess.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    npmProcess.on("close", (code) => {
+      if (code === 0) {
+        const lines = stdout.trim().split("\n");
+        const filename = lines.find((line) => line.trim().endsWith(".tgz")) || lines[lines.length - 1];
+        if (filename && filename.trim().endsWith(".tgz")) {
+          const fullPath = join(packDestDir, filename.trim());
+          res(fullPath);
+        } else {
+          rej(new Error("npm pack did not output a valid .tgz filename"));
+        }
+      } else {
+        const errorMessage = `npm pack failed with exit code ${code}`;
+        const fullError = stderr ? `${errorMessage}
+stderr: ${stderr}` : errorMessage;
+        if (stdout) {
+          rej(new Error(`${fullError}
+stdout: ${stdout}`));
+        } else {
+          rej(new Error(fullError));
+        }
+      }
+    });
+    npmProcess.on("error", (error) => {
+      rej(new Error(`Failed to spawn npm pack: ${error.message}`));
+    });
+  });
+};
+const packAssets = async (targetDir, outputDir, checkWorkingDirectoryStatus, alwaysOverrideVersionFromGit, inheritableFields, readmeReplacementPath, replacePeerDepsWildcards, peerDepsVersionPrefix, logger2) => {
+  var _a, _b, _c;
+  if (!existsSync(targetDir)) {
+    throw new Error(`Target directory is not found: ${targetDir}`);
+  }
+  let readmeReplacementCandidatePath = readmeReplacementPath;
+  if (readmeReplacementCandidatePath && !existsSync(readmeReplacementCandidatePath)) {
+    throw new Error(`README replacement file is not found: ${readmeReplacementCandidatePath}`);
+  }
+  const result = await resolveRawPackageJsonObject(
+    targetDir,
+    checkWorkingDirectoryStatus,
+    alwaysOverrideVersionFromGit,
+    inheritableFields,
+    logger2
+  );
+  let resolvedPackageJson = result.metadata;
+  if (resolvedPackageJson == null ? void 0 : resolvedPackageJson.private) {
+    return void 0;
+  }
+  const packageJsonReadme = resolvedPackageJson.readme;
+  if (packageJsonReadme) {
+    if (!readmeReplacementCandidatePath) {
+      const packageJsonReadmeDir = result.sourceMap.get("readme");
+      const packageJsonReadmePath = join(packageJsonReadmeDir, packageJsonReadme);
+      if (!existsSync(packageJsonReadmePath)) {
+        throw new Error(`README replacement file is not found: ${packageJsonReadmePath}`);
+      }
+      readmeReplacementCandidatePath = packageJsonReadmePath;
+    }
+    delete resolvedPackageJson.readme;
+  }
+  if (replacePeerDepsWildcards) {
+    const workspaceRoot = await findWorkspaceRoot(targetDir, logger2);
+    if (workspaceRoot) {
+      const siblings = await collectWorkspaceSiblings(workspaceRoot, logger2);
+      if (siblings.size > 0) {
+        resolvedPackageJson = replacePeerDependenciesWildcards(
+          resolvedPackageJson,
+          siblings,
+          peerDepsVersionPrefix
+        );
+      }
+    }
+  }
+  const baseTempDir = await mkdtemp(join(tmpdir(), "screw-up-npm-pack-"));
+  await mkdir(baseTempDir, { recursive: true });
+  try {
+    const npmTarballPath = await runNpmPack(targetDir, baseTempDir);
+    const stagingDir = join(baseTempDir, "staging");
+    await mkdir(stagingDir, { recursive: true });
+    const stream = createReadStream(npmTarballPath);
+    await extractTo(createTarExtractor(stream, "gzip"), stagingDir);
+    const packageJsonPath = join(stagingDir, "package", "package.json");
+    if (existsSync(packageJsonPath)) {
+      await writeFile(packageJsonPath, JSON.stringify(resolvedPackageJson, null, 2));
+    }
+    if (readmeReplacementCandidatePath) {
+      const readmeDestPath = join(stagingDir, "package", "README.md");
+      await copyFile(readmeReplacementCandidatePath, readmeDestPath);
+    }
+    const outputFileName = `${(_b = (_a = resolvedPackageJson == null ? void 0 : resolvedPackageJson.name) == null ? void 0 : _a.replace("/", "-")) != null ? _b : "package"}-${(_c = resolvedPackageJson == null ? void 0 : resolvedPackageJson.version) != null ? _c : "0.0.0"}.tgz`;
+    await mkdir(outputDir, { recursive: true });
+    const outputFile = join(outputDir, outputFileName);
+    const itemGenerator = createEntryItemGenerator(stagingDir);
+    const packer = createTarPacker(itemGenerator, "gzip");
+    await storeReaderToFile(packer, outputFile);
+    return {
+      packageFileName: outputFileName,
+      metadata: resolvedPackageJson
+    };
+  } finally {
+    await rm(baseTempDir, { recursive: true, force: true });
+  }
+};
+const getComputedPackageJsonObject = async (targetDir, checkWorkingDirectoryStatus, alwaysOverrideVersionFromGit, inheritableFields, logger2) => {
+  if (!existsSync(targetDir)) {
+    return void 0;
+  }
+  const result = await resolveRawPackageJsonObject(
+    targetDir,
+    checkWorkingDirectoryStatus,
+    alwaysOverrideVersionFromGit,
+    inheritableFields,
+    logger2
+  );
+  return result.metadata;
+};
+const parseArgs = (args, argOptionMap2) => {
+  const result = {
+    argv: args,
+    positional: [],
+    options: {}
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const optionName = arg.slice(2);
+      if (!result.command) {
+        result.options[optionName] = true;
+      } else {
+        const argOptions = argOptionMap2.get(result.command);
+        if (argOptions.has(optionName)) {
+          i++;
+          result.options[optionName] = args[i];
+        } else {
+          result.options[optionName] = true;
+        }
+      }
+    } else if (arg.startsWith("-")) {
+      const optionName = arg.slice(1);
+      if (optionName.length == 1) {
+        result.options[optionName] = true;
+      }
+    } else if (!result.command) {
+      result.command = arg;
+    } else {
+      result.positional.push(arg);
+    }
+  }
+  return result;
+};
+const defaultInheritableFields = /* @__PURE__ */ new Set([
+  "version",
+  "description",
+  "author",
+  "license",
+  "repository",
+  "keywords",
+  "homepage",
+  "bugs",
+  "readme"
+]);
+const parseInheritableFields = (inheritableFieldsOption) => {
+  if (typeof inheritableFieldsOption !== "string") {
+    return defaultInheritableFields;
+  }
+  if (!inheritableFieldsOption.trim()) {
+    return /* @__PURE__ */ new Set();
+  }
+  return new Set(inheritableFieldsOption.split(",").map((field) => field.trim()).filter((field) => field.length > 0));
+};
+const showDumpHelp = (logger2) => {
+  logger2.info(`Usage: screw-up dump [options] [directory]
+
+Dump computed package.json as JSON
+
+Arguments:
+  directory                     Directory to dump package.json from (default: current directory)
+
+Options:
+  --inheritable-fields <list>   Comma-separated list of fields to inherit from parent
+  --no-wds                      Do not check working directory status to increase version
+  --no-git-version-override     Do not override version from Git (use package.json version)
+  -h, --help                    Show help for dump command
+`);
+};
+const dumpCommand = async (args, logger2) => {
+  if (args.options.help || args.options.h) {
+    showDumpHelp(logger2);
+    return 1;
+  }
+  const directory = args.positional[0];
+  const inheritableFieldsOption = args.options["inheritable-fields"];
+  const alwaysOverrideVersionFromGit = !args.options["no-git-version-override"];
+  const checkWorkingDirectoryStatus = args.options["no-wds"] ? false : true;
+  const inheritableFields = parseInheritableFields(inheritableFieldsOption);
+  const targetDir = resolve(directory != null ? directory : process.cwd());
+  try {
+    const computedPackageJson = await getComputedPackageJsonObject(
+      targetDir,
+      checkWorkingDirectoryStatus,
+      alwaysOverrideVersionFromGit,
+      inheritableFields,
+      logger2
+    );
+    if (computedPackageJson) {
+      logger2.info(JSON.stringify(computedPackageJson, null, 2));
+    } else {
+      logger2.error(`[screw-up:cli]: dump: Unable to read package.json from: ${targetDir}`);
+      return 1;
+    }
+  } catch (error) {
+    logger2.error(`[screw-up:cli]: dump: Failed to dump package.json: ${error}`);
+    return 1;
+  }
+  return 0;
+};
+const showPackHelp = (logger2) => {
+  logger2.info(`Usage: screw-up pack [options] [directory]
+
+Pack the project into a tar archive
+
+Arguments:
+  directory                     Directory to pack (default: current directory)
+
+Options:
+  --pack-destination <path>     Directory to write the tarball
+  --readme <path>               Replace README.md with specified file
+  --inheritable-fields <list>   Comma-separated list of fields to inherit from parent
+  --no-wds                      Do not check working directory status to increase version
+  --no-git-version-override     Do not override version from Git (use package.json version)
+  --no-replace-peer-deps        Disable replacing "*" in peerDependencies with actual versions
+  --peer-deps-prefix <prefix>   Version prefix for replaced peerDependencies (default: "^")
+  --verbose                     Print verbose log
+  -h, --help                    Show help for pack command
+`);
+};
+const packCommand = async (args, logger2) => {
+  var _a;
+  if (args.options.help || args.options.h) {
+    showPackHelp(logger2);
+    return 1;
+  }
+  const directory = args.positional[0];
+  const packDestination = args.options["pack-destination"];
+  const readmeOption = args.options["readme"];
+  const inheritableFieldsOption = args.options["inheritable-fields"];
+  const checkWorkingDirectoryStatus = args.options["no-wds"] ? false : true;
+  const alwaysOverrideVersionFromGit = !args.options["no-git-version-override"];
+  const replacePeerDepsWildcards = !args.options["no-replace-peer-deps"];
+  const peerDepsVersionPrefix = (_a = args.options["peer-deps-prefix"]) != null ? _a : "^";
+  const verbose = args.options["verbose"] ? true : false;
+  const targetDir = resolve(directory != null ? directory : process.cwd());
+  const outputDir = packDestination ? resolve(packDestination) : process.cwd();
+  const readmeReplacementPath = readmeOption ? resolve(readmeOption) : void 0;
+  const inheritableFields = parseInheritableFields(inheritableFieldsOption);
+  if (verbose) {
+    logger2.info(`[screw-up:cli]: pack: Creating archive of ${targetDir}...`);
+  }
+  try {
+    const result = await packAssets(
+      targetDir,
+      outputDir,
+      checkWorkingDirectoryStatus,
+      alwaysOverrideVersionFromGit,
+      inheritableFields,
+      readmeReplacementPath,
+      replacePeerDepsWildcards,
+      peerDepsVersionPrefix,
+      logger2
+    );
+    if (result) {
+      if (verbose) {
+        logger2.info(`[screw-up:cli]: pack: Archive created successfully: ${result.packageFileName}`);
+      } else {
+        logger2.info(result.packageFileName);
+      }
+    } else {
+      logger2.error(`[screw-up:cli]: pack: Unable to find any files to pack: ${targetDir}`);
+      return 1;
+    }
+  } catch (error) {
+    logger2.error(`[screw-up:cli]: pack: Failed to create archive: ${error}`);
+    return 1;
+  }
+  return 0;
+};
+const showPublishHelp = (logger2) => {
+  logger2.info(`Usage: screw-up publish [options] [directory|package.tgz]
+
+Publish the project
+
+Arguments:
+  directory|package.tgz         Directory to pack and publish, or existing tarball to publish
+
+Options:
+  All npm publish options are supported, including:
+  --dry-run                     Perform a dry run
+  --tag <tag>                   Tag for the published version
+  --access <access>             Access level (public or restricted)
+  --registry <registry>         Registry URL
+  -h, --help                    Show help for publish command
+
+Examples:
+  screw-up publish                       # Publish current directory
+  screw-up publish ./my-project          # Publish specific directory
+  screw-up publish package.tgz           # Publish existing tarball
+  screw-up publish --dry-run --tag beta  # Publish with options
+`);
+};
+const runNpmPublish = async (tarballPath, npmOptions, verbose, logger2) => {
+  if (verbose) {
+    logger2.info(`[screw-up:cli]: publish: Publishing ${tarballPath} to npm...`);
+  }
+  const publishArgs = ["publish", tarballPath, ...npmOptions];
+  if (process.env.SCREW_UP_TEST_MODE === "true") {
+    logger2.info(`[screw-up:cli]: TEST_MODE: Would execute: npm ${publishArgs.join(" ")}`);
+    logger2.info(`[screw-up:cli]: TEST_MODE: Tarball path: ${tarballPath}`);
+    logger2.info(`[screw-up:cli]: TEST_MODE: Options: ${npmOptions.join(" ")}`);
+    logger2.info(`[screw-up:cli]: publish: Successfully published ${tarballPath}`);
+    return 0;
+  }
+  const npmProcess = spawn("npm", publishArgs, { stdio: "inherit" });
+  return new Promise((resolve2, reject) => {
+    npmProcess.on("close", (code) => {
+      if (code === 0) {
+        if (verbose) {
+          logger2.info(`[screw-up:cli]: publish: Successfully published ${tarballPath}`);
+        }
+        resolve2(code);
+      } else {
+        logger2.error(`[screw-up:cli]: publish: npm publish failed: ${tarballPath}`);
+        resolve2(code);
+      }
+    });
+    npmProcess.on("error", reject);
+  });
+};
+const publishCommand = async (args, logger2) => {
+  var _a;
+  if (args.options.help || args.options.h) {
+    showPublishHelp(logger2);
+    return 1;
+  }
+  const path = args.positional[0];
+  const readmeOption = args.options["readme"];
+  const inheritableFieldsOption = args.options["inheritable-fields"];
+  const checkWorkingDirectoryStatus = args.options["no-wds"] ? false : true;
+  const alwaysOverrideVersionFromGit = !args.options["no-git-version-override"];
+  const replacePeerDepsWildcards = !args.options["no-replace-peer-deps"];
+  const peerDepsVersionPrefix = (_a = args.options["peer-deps-prefix"]) != null ? _a : "^";
+  const verbose = args.options["verbose"] ? true : false;
+  const inheritableFields = parseInheritableFields(inheritableFieldsOption);
+  const readmeReplacementPath = readmeOption ? resolve(readmeOption) : void 0;
+  const npmOptions = [];
+  for (let i = 0; i < args.argv.length; i++) {
+    const arg = args.argv[i];
+    if (arg === "--help" || arg === "--verbose" || arg === "-h" || arg === "--no-wds" || arg === "--no-git-version-override" || arg === "--no-replace-peer-deps") ;
+    else if (arg === "--readme" || arg === "--inheritable-fields" || arg === "--peer-deps-prefix") {
+      i++;
+    } else {
+      npmOptions.push(arg);
+    }
+  }
+  try {
+    if (!path) {
+      const targetDir = process.cwd();
+      const outputDir = await mkdtemp("screw-up-publish-");
+      if (verbose) {
+        logger2.info(`[screw-up:cli]: publish: Creating archive of ${targetDir}...`);
+      }
+      try {
+        const result = await packAssets(
+          targetDir,
+          outputDir,
+          checkWorkingDirectoryStatus,
+          alwaysOverrideVersionFromGit,
+          inheritableFields,
+          readmeReplacementPath,
+          replacePeerDepsWildcards,
+          peerDepsVersionPrefix,
+          logger2
+        );
+        if (result == null ? void 0 : result.metadata) {
+          if (verbose) {
+            logger2.info(`[screw-up:cli]: publish: Archive created successfully: ${result.packageFileName}`);
+          }
+          const archiveName = `${result.metadata.name}-${result.metadata.version}.tgz`;
+          const archivePath = join(outputDir, archiveName);
+          return await runNpmPublish(archivePath, npmOptions, verbose, logger2);
+        } else {
+          logger2.error(`[screw-up:cli]: publish: Unable to find any files to pack: ${targetDir}`);
+          return 1;
+        }
+      } finally {
+        await rm(outputDir, { recursive: true, force: true });
+      }
+    } else if (existsSync(path)) {
+      const pathStat = await stat(path);
+      if (pathStat.isFile() && (path.endsWith(".tgz") || path.endsWith(".tar.gz"))) {
+        return await runNpmPublish(resolve(path), npmOptions, verbose, logger2);
+      } else if (pathStat.isDirectory()) {
+        const targetDir = resolve(path);
+        const outputDir = await mkdtemp("screw-up-publish-");
+        if (verbose) {
+          logger2.info(`[screw-up:cli]: publish: Creating archive of ${targetDir}...`);
+        }
+        try {
+          const result = await packAssets(
+            targetDir,
+            outputDir,
+            checkWorkingDirectoryStatus,
+            alwaysOverrideVersionFromGit,
+            inheritableFields,
+            readmeReplacementPath,
+            replacePeerDepsWildcards,
+            peerDepsVersionPrefix,
+            logger2
+          );
+          if (result == null ? void 0 : result.metadata) {
+            if (verbose) {
+              logger2.info(`[screw-up:cli]: publish: Archive created successfully: ${result.packageFileName}`);
+            }
+            const archiveName = `${result.metadata.name}-${result.metadata.version}.tgz`;
+            const archivePath = join(outputDir, archiveName);
+            return await runNpmPublish(archivePath, npmOptions, verbose, logger2);
+          } else {
+            logger2.error(`[screw-up:cli]: publish: Unable to find any files to pack: ${targetDir}`);
+            return 1;
+          }
+        } finally {
+          await rm(outputDir, { recursive: true, force: true });
+        }
+      } else {
+        logger2.error(`[screw-up:cli]: publish: Invalid path - must be a directory or .tgz/.tar.gz file: ${path}`);
+        return 1;
+      }
+    } else {
+      logger2.error(`[screw-up:cli]: publish: Path does not exist: ${path}`);
+      return 1;
+    }
+  } catch (error) {
+    logger2.error(`[screw-up:cli]: publish: Failed to publish: ${error}`);
+    return 1;
+  }
+};
+const showHelp = async (logger2) => {
+  const { author, license, repository_url, version } = await import("./packageMetadata-Dsxn2dKN.js");
+  logger2.info(`screw-up - Easy package metadata inserter CLI [${version}]
+Copyright (c) ${author}
+Repository: ${repository_url}
+License: ${license}
+
+Usage: screw-up <command> [options]
+
+Commands:
+  dump [directory]                 Dump computed package.json as JSON
+  pack [directory]                 Pack the project into a tar archive
+  publish [directory|package.tgz]  Publish the project
+
+Options:
+  -h, --help                       Show help
+
+Examples:
+  screw-up dump                            # Dump computed package.json as JSON
+  screw-up pack                            # Pack current directory
+  screw-up pack --pack-destination ./dist  # Pack to specific output directory
+  screw-up publish                         # Publish current directory
+  screw-up publish package.tgz             # Publish existing tarball
+`);
+};
+const argOptionMap = /* @__PURE__ */ new Map([
+  ["dump", /* @__PURE__ */ new Set(["inheritable-fields"])],
+  ["pack", /* @__PURE__ */ new Set(["pack-destination", "readme", "inheritable-fields", "peer-deps-prefix"])],
+  ["publish", /* @__PURE__ */ new Set(["inheritable-fields", "peer-deps-prefix"])]
+]);
+const cliMain = async (args, logger2) => {
+  const parsedArgs = parseArgs(args, argOptionMap);
+  if (!parsedArgs.command && (parsedArgs.options.help || parsedArgs.options.h)) {
+    await showHelp(logger2);
+    return 1;
+  }
+  switch (parsedArgs.command) {
+    case "dump":
+      return await dumpCommand(parsedArgs, logger2);
+    case "pack":
+      return await packCommand(parsedArgs, logger2);
+    case "publish":
+      return await publishCommand(parsedArgs, logger2);
+    default:
+      if (parsedArgs.command) {
+        logger2.error(`Unknown command: ${parsedArgs.command}`);
+      } else {
+        logger2.error(`Unknown command`);
+      }
+      logger2.error('Run "screw-up --help" for usage information.');
+      return 1;
+  }
+};
+const logger = createConsoleLogger();
+cliMain(
+  process.argv.slice(2),
+  // Remove 'node' and script path
+  logger
+).then((code) => process.exit(code)).catch((error) => {
+  logger.error(`CLI error: ${error}`);
+  process.exit(1);
+});
+//# sourceMappingURL=main.js.map