@uipath/vertical-solutions-tool 1.204.0 → 1.205.0-preview.258

package/dist/tool-yx29vb63.js

@@ -0,0 +1,672 @@
+import {
+  Unzip,
+  UnzipInflate,
+  UnzipPassThrough
+} from "./tool-67587985.js";
+import {
+  SEED_ROOT_DIR,
+  acquireSeedWorkspaceLock,
+  errorCode,
+  insideSeedRoot,
+  isCaseInsensitiveDisk,
+  isDanglingLink,
+  isInsideWorkspace,
+  isMissingOrNotADirectory,
+  isPreservedWorkspaceFile,
+  namesSeedRoot,
+  reservedOnThisPlatform,
+  seedRoot,
+  tempPathFor,
+  workspaceRoot
+} from "./tool-s9qbxa2g.js";
+import {
+  catchError
+} from "./tool-pz9qm3dv.js";
+import {
+  getFileSystem
+} from "./tool-hdxtgckw.js";
+
+// src/services/seed/template-apply.ts
+import { randomUUID } from "node:crypto";
+
+// src/services/seed/folder-links.ts
+async function isFolderLink(root, relativeDir) {
+  return await folderLinkState(root, relativeDir) !== "own";
+}
+async function folderLinkState(root, relativeDir) {
+  const fs = getFileSystem();
+  const absolute = fs.path.join(root.lexical, relativeDir);
+  if (await isDanglingLink(absolute))
+    return "link";
+  const real = await fs.realpath(absolute);
+  const resolved = real.normalize("NFC");
+  const expected = fs.path.join(root.real, relativeDir).normalize("NFC");
+  if (resolved === expected)
+    return "own";
+  if (resolved.toLowerCase() !== expected.toLowerCase())
+    return "link";
+  const folds = await isCaseInsensitiveDisk(root);
+  if (folds === true)
+    return "own";
+  return folds === false ? "link" : "unknown";
+}
+
+// src/services/seed/template-apply.ts
+function linkEscapeError(relativePath) {
+  return new Error(`The seed workspace path ${relativePath} is a link that leads outside ` + "the workspace; refusing to write through it. Remove the link and " + "refresh again.");
+}
+function folderLinkError(relativePath, folder) {
+  return new Error(`The seed workspace path ${relativePath} goes through ${folder}, which ` + "is a folder link; refusing to write through it. Replace the link " + "with a real folder and refresh again.");
+}
+function fileLinkError(relativePath) {
+  return new Error(`The seed workspace path ${relativePath} is a link; refusing to ` + "replace it. Replace the link with a real file and refresh again.");
+}
+async function mkdirInsideWorkspace(root, relativePath, staging) {
+  const fs = getFileSystem();
+  const created = staging.createdDirs;
+  const segments = relativePath.split("/").slice(0, -1);
+  for (let depth = 1;depth <= segments.length; depth += 1) {
+    const relativeDir = segments.slice(0, depth).join("/");
+    const current = fs.path.join(root.lexical, relativeDir);
+    if (await isDisplacedByFolder(current) && await isInsideWorkspace(root, current) && !await isFolderLink(root, relativeDir)) {
+      const backup = `${current}.${randomUUID()}.uip-old`;
+      await step(fs.rename(current, backup), relativeDir);
+      staging.displaced.push({ target: current, backup });
+    }
+    if (!await fs.exists(current)) {
+      if (await isDanglingLink(current)) {
+        throw folderLinkError(relativePath, relativeDir);
+      }
+      await fs.mkdir(current);
+      created.push(current);
+      if (await isDanglingLink(current)) {
+        throw folderLinkError(relativePath, relativeDir);
+      }
+    }
+    if (!await isInsideWorkspace(root, current)) {
+      throw linkEscapeError(relativePath);
+    }
+    if (await isFolderLink(root, relativeDir)) {
+      throw folderLinkError(relativePath, relativeDir);
+    }
+  }
+}
+async function isDisplacedByFolder(current) {
+  const fs = getFileSystem();
+  const [statError, stats] = await catchError(fs.stat(current));
+  if (statError || !stats)
+    return false;
+  return !stats.isDirectory();
+}
+async function checkedTarget(root, relativePath) {
+  const fs = getFileSystem();
+  const target = fs.path.join(root.lexical, relativePath);
+  if (!await isInsideWorkspace(root, target)) {
+    throw linkEscapeError(relativePath);
+  }
+  if (await fs.exists(target) && await isFolderLink(root, relativePath)) {
+    throw fileLinkError(relativePath);
+  }
+  return target;
+}
+async function applyEntries(root, entries) {
+  const staging = {
+    entries: [],
+    createdDirs: [],
+    displaced: []
+  };
+  const [applyError] = await catchError(stageAndSwap(root, entries, staging));
+  if (!applyError)
+    return;
+  const leftovers = await rollBack(staging);
+  const undone = leftovers.length === 0 ? " Nothing in the seed workspace was changed." : ` Could not put everything back: ${leftovers.join("; ")}.`;
+  throw new Error(`${applyError.message}${undone}`);
+}
+async function stageAndSwap(root, entries, staging) {
+  const fs = getFileSystem();
+  for (const [relativePath, bytes] of entries) {
+    await mkdirInsideWorkspace(root, relativePath, staging);
+    const target = await checkedTarget(root, relativePath);
+    const entry = {
+      relativePath,
+      target,
+      temp: tempPathFor(target),
+      swapped: false
+    };
+    staging.entries.push(entry);
+    await step(fs.writeFile(entry.temp, bytes), relativePath);
+  }
+  for (const entry of staging.entries)
+    await moveAside(entry);
+  for (const entry of staging.entries) {
+    await step(fs.rename(entry.temp, entry.target), entry.relativePath);
+    entry.swapped = true;
+  }
+}
+async function moveAside(entry) {
+  const fs = getFileSystem();
+  const [statError, stats] = await catchError(fs.stat(entry.target));
+  if (statError)
+    throw writeFailure(entry.relativePath, statError);
+  const backup = `${entry.target}.${randomUUID()}.uip-old`;
+  if (!stats) {
+    const [listError] = await catchError(fs.readdir(fs.path.dirname(entry.target)));
+    if (!listError) {
+      if (!await isDanglingLink(entry.target))
+        return;
+    } else {
+      const [renameError] = await catchError(fs.rename(entry.target, backup));
+      if (renameError) {
+        if (isMissingOrNotADirectory(renameError))
+          return;
+        throw writeFailure(entry.relativePath, renameError);
+      }
+      entry.backup = backup;
+      return;
+    }
+  }
+  await step(fs.rename(entry.target, backup), entry.relativePath);
+  entry.backup = backup;
+}
+async function step(operation, relativePath) {
+  const [error] = await catchError(operation);
+  if (error)
+    throw writeFailure(relativePath, error);
+}
+function writeFailure(relativePath, error) {
+  return new Error(`Could not write ${relativePath}: ${error.message}. Close anything ` + "holding it open and refresh again.");
+}
+async function rollBack(staging) {
+  const fs = getFileSystem();
+  const leftovers = [];
+  for (const entry of [...staging.entries].reverse()) {
+    const [error] = await catchError(undoEntry(entry));
+    if (error)
+      leftovers.push(await leftoverNote(entry, error));
+  }
+  for (const dir of [...staging.createdDirs].reverse()) {
+    await catchError(fs.rm(dir));
+  }
+  for (const moved of [...staging.displaced].reverse()) {
+    const [error] = await catchError(fs.rename(moved.backup, moved.target));
+    if (error) {
+      leftovers.push(`${moved.target} (${error.message}), its previous copy is at ${moved.backup}`);
+    }
+  }
+  return leftovers;
+}
+async function undoEntry(entry) {
+  const fs = getFileSystem();
+  if (entry.backup && entry.swapped) {
+    await restoreOverSwapped(entry.backup, entry.target);
+  } else if (entry.backup) {
+    await fs.rename(entry.backup, entry.target);
+  } else if (entry.swapped) {
+    await fs.rm(entry.target);
+  }
+  if (!entry.swapped)
+    await fs.rm(entry.temp);
+}
+async function restoreOverSwapped(backup, target) {
+  const fs = getFileSystem();
+  const [error] = await catchError(fs.rename(backup, target));
+  if (!error)
+    return;
+  if (errorCode(error) !== "ENOTDIR")
+    throw error;
+  await fs.rm(target);
+  await fs.rename(backup, target);
+}
+async function leftoverNote(entry, error) {
+  const note = `${entry.relativePath} (${error.message})`;
+  const backup = entry.backup;
+  if (!backup)
+    return note;
+  const [probeError, kept] = await catchError(async () => {
+    if (await getFileSystem().exists(backup))
+      return true;
+    return isDanglingLink(backup);
+  });
+  return probeError || kept ? `${note}, its previous copy is at ${backup}` : note;
+}
+
+// src/services/seed/path-folding.ts
+function exactPath(path) {
+  return path.normalize("NFC");
+}
+function foldPath(path) {
+  return path.split("/").map((segment) => segment.replace(/[. ]+$/, "").normalize("NFC").toLowerCase()).join("/");
+}
+
+// src/services/seed/path-segments.ts
+var CONTROL_BYTES = /[\u0000-\u001F\u007F-\u009F]/;
+var CONTROL_BYTES_ALL = /[\u0000-\u001F\u007F-\u009F]/g;
+function isUnsafeSegment(segment) {
+  return isDotSegment(segment) || segmentNameProblem(segment) !== undefined;
+}
+function withoutControlBytes(text) {
+  return text.replace(CONTROL_BYTES_ALL, "");
+}
+function isDotSegment(segment) {
+  return segment.replace(/[. ]+$/, "") === "";
+}
+function segmentNameProblem(segment) {
+  if (CONTROL_BYTES.test(segment)) {
+    return `"${withoutControlBytes(segment)}" contains a control character`;
+  }
+  if (segment.includes(":"))
+    return `"${segment}" contains ":"`;
+  if (reservedOnThisPlatform(segment)) {
+    return `Windows reserves "${segment}" as a device name`;
+  }
+  if (/[. ]$/.test(segment))
+    return `"${segment}" ends in a dot or a space`;
+  return;
+}
+
+// src/services/seed/template-archive.ts
+var MAX_ENTRIES = 2000;
+var MAX_TOTAL_BYTES = 64 * 1024 * 1024;
+var ARCHIVE_LIMITS = {
+  maxEntries: MAX_ENTRIES,
+  maxTotalBytes: MAX_TOTAL_BYTES
+};
+function extractSeedEntries(zip, limits = ARCHIVE_LIMITS) {
+  const entries = new Map;
+  const directories = [];
+  const skipped = [];
+  const warnings = [];
+  if (zip.length === 0) {
+    return { entries, directories, skipped, warnings };
+  }
+  const claimed = new Map;
+  const claimedFolders = new Map;
+  const inflated = inflateWithinLimits(zip, limits);
+  for (const name of inflated.directories) {
+    if (unsafeDirectoryEntry(name)) {
+      skipped.push(name);
+      continue;
+    }
+    const relative = toWorkspacePath(name.replace(/[\\/]+$/, ""));
+    if (relative === undefined)
+      continue;
+    claimFolders(claimedFolders, relative.split("/"), name);
+    directories.push(relative);
+  }
+  for (const [name, bytes] of inflated.files) {
+    const relative = toWorkspacePath(name);
+    if (relative === undefined) {
+      skipped.push(name);
+      continue;
+    }
+    claimPath(claimed, relative, name);
+    claimFolders(claimedFolders, relative.split("/").slice(0, -1), name);
+    entries.set(relative, bytes);
+  }
+  const asFolders = new Set([
+    ...directories.map(foldPath),
+    ...claimedFolders.keys()
+  ]);
+  for (const relative of entries.keys()) {
+    if (asFolders.has(foldPath(relative))) {
+      skipped.push(`${SEED_ROOT_DIR}/${relative}`);
+    }
+  }
+  if (skipped.length > 0) {
+    warnings.push(`Ignored ${skipped.length} archive ${skipped.length === 1 ? "entry" : "entries"} outside 'seeding/': ${quoteEntryNames(skipped)}`);
+  }
+  return { entries, directories, skipped, warnings };
+}
+function quoteEntryNames(names) {
+  return names.slice(0, 5).map(quoteEntryName).join(", ");
+}
+function quoteEntryName(name) {
+  return JSON.stringify(name).replace(/[\u007F-\u009F]/g, (byte) => {
+    const code = byte.codePointAt(0) ?? 0;
+    return `\\u${code.toString(16).padStart(4, "0")}`;
+  });
+}
+function claimFolders(claimed, segments, name) {
+  for (let depth = 1;depth <= segments.length; depth += 1) {
+    claimFolder(claimed, segments.slice(0, depth).join("/"), name);
+  }
+}
+function claimFolder(claimed, relative, name) {
+  const folded = foldPath(relative);
+  const earlier = claimed.get(folded);
+  if (earlier === undefined) {
+    claimed.set(folded, relative);
+    return;
+  }
+  if (earlier === relative)
+    return;
+  throw new Error("The seed-template archive spells one folder two ways " + `(${quoteEntryName(`${SEED_ROOT_DIR}/${earlier}`)} and ` + `${quoteEntryName(`${SEED_ROOT_DIR}/${relative}`)}, in ` + `${quoteEntryName(name)}); on a disk that does not tell them ` + "apart they would merge into one folder, so the archive is " + "refused and the seed workspace is left as it is.");
+}
+function claimPath(claimed, relative, name) {
+  const folded = foldPath(relative);
+  const earlier = claimed.get(folded);
+  if (earlier !== undefined) {
+    throw new Error(`The seed-template archive has two entries for the same file ` + `('${earlier}' and '${name}'); refusing it and leaving the ` + "seed workspace as it is.");
+  }
+  claimed.set(folded, name);
+}
+function inflateWithinLimits(zip, limits) {
+  const files = [];
+  const directories = [];
+  let entryCount = 0;
+  let totalBytes = 0;
+  const unzipper = new Unzip((file) => {
+    entryCount += 1;
+    if (entryCount > limits.maxEntries) {
+      throw new Error(`The seed-template archive holds more than ${limits.maxEntries} entries, ` + `over the ${limits.maxEntries} limit; refusing to extract it.`);
+    }
+    if (/[\\/]$/.test(file.name)) {
+      directories.push(file.name);
+      return;
+    }
+    const chunks = [];
+    let size = 0;
+    file.ondata = (error, chunk, final) => {
+      if (error)
+        throw error;
+      totalBytes += chunk.length;
+      if (totalBytes > limits.maxTotalBytes) {
+        throw new Error(`The seed-template archive expands past the ${describeBytes(limits.maxTotalBytes)} limit; refusing to extract it.`);
+      }
+      chunks.push(chunk);
+      size += chunk.length;
+      if (final)
+        files.push([file.name, concat(chunks, size)]);
+    };
+    file.start();
+  });
+  unzipper.register(UnzipInflate);
+  unzipper.register(UnzipPassThrough);
+  unzipper.push(zip, true);
+  return { files, directories };
+}
+function unsafeDirectoryEntry(name) {
+  const trimmed = name.replace(/[\\/]+$/, "");
+  const normalized = trimmed.replaceAll("\\", "/");
+  if (normalized === SEED_ROOT_DIR)
+    return false;
+  return toWorkspacePath(trimmed) === undefined;
+}
+function concat(chunks, size) {
+  if (chunks.length === 1)
+    return chunks[0];
+  const out = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return out;
+}
+function describeBytes(bytes) {
+  const mb = bytes / (1024 * 1024);
+  return mb >= 1 ? `${Math.round(mb)} MB` : `${bytes} byte`;
+}
+function toWorkspacePath(name) {
+  const normalized = name.replaceAll("\\", "/");
+  if (normalized.startsWith("/") || /^[a-zA-Z]:/.test(normalized)) {
+    return;
+  }
+  const segments = normalized.split("/").filter((segment) => segment !== "");
+  if (segments.length < 2)
+    return;
+  if (segments[0] !== SEED_ROOT_DIR)
+    return;
+  if (segments.some(isUnsafeSegment))
+    return;
+  const relative = segments.slice(1);
+  if (relative.some(isPreservedWorkspaceFile))
+    return;
+  return relative.join("/");
+}
+
+// src/services/seed/template-prune.ts
+async function removeStaleFiles(root, keptPaths, keptDirs = []) {
+  const warnings = [];
+  const [probeError, folds] = await catchError(isCaseInsensitiveDisk(root));
+  if (probeError || folds === undefined) {
+    warnings.push(`Could not tell whether the disk folds case (${probeError?.message ?? "the probe was inconclusive"}), so any file whose name differs only in case from one the ` + "archive brought was kept. Remove it by hand if it is stale, " + "or it will still be seeded.");
+  }
+  const kept = {
+    files: new Set,
+    dirs: new Set,
+    filesExact: new Set,
+    dirsExact: new Set,
+    exact: new Set,
+    keepAll: new Set,
+    keepAllExact: new Set,
+    foldsCase: folds !== false
+  };
+  for (const path of keptPaths) {
+    const segments = path.split("/");
+    for (let depth = 1;depth <= segments.length; depth += 1) {
+      const prefix = segments.slice(0, depth).join("/");
+      kept.exact.add(exactPath(prefix));
+      const file = depth === segments.length;
+      (file ? kept.files : kept.dirs).add(foldPath(prefix));
+      (file ? kept.filesExact : kept.dirsExact).add(exactPath(prefix));
+    }
+  }
+  for (const path of keptDirs) {
+    const segments = path.split("/");
+    for (let depth = 1;depth <= segments.length; depth += 1) {
+      const prefix = segments.slice(0, depth).join("/");
+      kept.exact.add(exactPath(prefix));
+      kept.dirs.add(foldPath(prefix));
+      kept.dirsExact.add(exactPath(prefix));
+    }
+    if (holdsArchivedFile(path, kept))
+      continue;
+    kept.keepAll.add(foldPath(path));
+    kept.keepAllExact.add(exactPath(path));
+  }
+  await pruneDir(root, "", kept, warnings);
+  return warnings;
+}
+function holdsArchivedFile(dir, kept) {
+  const under = (paths, prefix) => {
+    const wanted = `${exactPath(prefix)}/`;
+    for (const path of paths) {
+      if (exactPath(path).startsWith(wanted))
+        return true;
+    }
+    return false;
+  };
+  if (under(kept.filesExact, dir))
+    return true;
+  return kept.foldsCase && under(kept.files, foldPath(dir));
+}
+function exactlyListed(relatives, kept) {
+  return new Set(relatives.filter((relative) => kept.exact.has(exactPath(relative))).map(foldPath));
+}
+async function pruneDir(root, relativeDir, kept, warnings) {
+  const fs = getFileSystem();
+  if (relativeDir !== "" && !await isRealFolder(root, relativeDir, warnings)) {
+    return;
+  }
+  const [listError, entries] = await catchError(fs.readdir(fs.path.join(root.lexical, relativeDir)));
+  if (listError) {
+    warnings.push(`Could not list ${relativeDir || "the workspace"} to remove stale ` + `files: ${listError.message}. Check it by hand, or a stale CSV ` + "or attachment there will still be seeded.");
+    return;
+  }
+  if (!entries)
+    return;
+  const relatives = entries.filter((entry) => !isPreservedWorkspaceFile(entry)).map((entry) => relativeDir ? `${relativeDir}/${entry}` : entry);
+  const exact = exactlyListed(relatives, kept);
+  for (const relative of relatives) {
+    const folded = foldPath(relative);
+    const shadowed = exact.has(folded) && !kept.exact.has(exactPath(relative));
+    const matches = (exactSet, foldedSet) => exactSet.has(exactPath(relative)) || kept.foldsCase && foldedSet.has(folded);
+    if (!shadowed && matches(kept.keepAllExact, kept.keepAll)) {
+      if (await isDeclaredFolder(root, relative, warnings))
+        continue;
+      await removeStale(root, relative, warnings);
+      continue;
+    }
+    if (!shadowed && matches(kept.filesExact, kept.files))
+      continue;
+    if (!shadowed && matches(kept.dirsExact, kept.dirs)) {
+      await pruneDir(root, relative, kept, warnings);
+      continue;
+    }
+    await removeStale(root, relative, warnings);
+  }
+}
+async function isDeclaredFolder(root, relative, warnings) {
+  const fs = getFileSystem();
+  const [statError, stats] = await catchError(fs.stat(fs.path.join(root.lexical, relative)));
+  if (statError || !stats) {
+    warnings.push(`Kept ${relative}: could not check whether it is still a folder (${statError?.message ?? "the check was inconclusive"}). Remove it by hand if it is stale, or it will still be seeded.`);
+    return true;
+  }
+  if (!stats.isDirectory())
+    return false;
+  const [linkError, state] = await catchError(folderLinkState(root, relative));
+  if (linkError || state === "unknown") {
+    warnings.push(`Kept ${relative}: could not tell whether it is a link (${linkError?.message ?? "the disk would not say whether it folds case"}). Remove it by hand if it is stale, or it will still be seeded.`);
+    return true;
+  }
+  return state === "own";
+}
+async function removeStale(root, relative, warnings) {
+  if (!await staysInside(root, relative, warnings))
+    return;
+  const [linkError, state] = await catchError(folderLinkState(root, relative));
+  if (linkError || state === "unknown") {
+    warnings.push(`Left ${relative} alone: could not tell whether it is a link (${linkError?.message ?? "the disk would not say whether it folds case"}). Remove it by hand if it is stale, or it will still be seeded.`);
+    return;
+  }
+  const linked = state === "link";
+  if (!linked && await holdsPreservedFile(root, relative)) {
+    await removeStaleFolder(root, relative, warnings);
+    return;
+  }
+  await remove(root, relative, warnings);
+}
+async function remove(root, relative, warnings) {
+  const fs = getFileSystem();
+  const [rmError] = await catchError(fs.rm(fs.path.join(root.lexical, relative)));
+  if (rmError) {
+    warnings.push(`Could not remove the stale ${relative}: ${rmError.message}. ` + "Delete it by hand, or it will still be seeded.");
+  }
+}
+async function holdsPreservedFile(root, relative) {
+  const fs = getFileSystem();
+  const [linkError, linked] = await catchError(isFolderLink(root, relative));
+  if (linkError)
+    return true;
+  if (linked)
+    return false;
+  const [listError, entries] = await catchError(fs.readdir(fs.path.join(root.lexical, relative)));
+  if (listError)
+    return !isMissingOrNotADirectory(listError);
+  if (!entries)
+    return false;
+  for (const entry of entries) {
+    if (isPreservedWorkspaceFile(entry))
+      return true;
+    if (await holdsPreservedFile(root, `${relative}/${entry}`))
+      return true;
+  }
+  return false;
+}
+async function removeStaleFolder(root, relative, warnings) {
+  const fs = getFileSystem();
+  const dir = fs.path.join(root.lexical, relative);
+  const [linkError, linked] = await catchError(isFolderLink(root, relative));
+  if (linkError || linked) {
+    warnings.push(`Left ${relative} alone: ${linkError ? `could not check whether it is a link (${linkError.message})` : "it is a link, not the folder this prune found"}. Remove it by hand if it is stale, or it will still be seeded.`);
+    return;
+  }
+  const [listError, entries] = await catchError(fs.readdir(dir));
+  if (listError || !entries) {
+    warnings.push(`Could not list the stale ${relative}: ${listError?.message ?? "no entries"}. Delete it by hand, or it will still be seeded.`);
+    return;
+  }
+  for (const entry of entries) {
+    if (isPreservedWorkspaceFile(entry))
+      continue;
+    await removeStale(root, `${relative}/${entry}`, warnings);
+  }
+  const [, left] = await catchError(fs.readdir(dir));
+  if (left && left.length === 0) {
+    await remove(root, relative, warnings);
+    return;
+  }
+  warnings.push(`Left the stale ${relative} in place: it still holds files this prune ` + "never deletes. Remove it by hand if you do not need them.");
+}
+async function staysInside(root, relative, warnings) {
+  const path = getFileSystem().path.join(root.lexical, relative);
+  const [checkError, inside] = await catchError(isInsideWorkspace(root, path));
+  if (!checkError && inside)
+    return true;
+  warnings.push(`Left ${relative} alone: ${checkError ? `could not check where it leads (${checkError.message})` : "it is a link that leads outside the workspace"}. Remove it by hand if it is stale, or it will still be seeded.`);
+  return false;
+}
+async function isRealFolder(root, relativeDir, warnings) {
+  if (!await staysInside(root, relativeDir, warnings))
+    return false;
+  const [checkError, linked] = await catchError(isFolderLink(root, relativeDir));
+  if (!checkError && !linked)
+    return true;
+  warnings.push(`Left ${relativeDir} alone: it is a folder link, so its files were not ` + "checked. Remove it by hand if it is stale, or it will still be seeded.");
+  return false;
+}
+
+// src/services/seed/templates.ts
+async function refreshSeedTemplates(options) {
+  const fs = getFileSystem();
+  const dir = options.dir;
+  const extracted = extractSeedEntries(options.zip);
+  if (extracted.skipped.length > 0) {
+    throw new Error(`The seed-template archive has ${extracted.skipped.length} unsafe or ` + `out-of-scope ${extracted.skipped.length === 1 ? "entry" : "entries"} ` + `(${quoteEntryNames(extracted.skipped)}); refusing it and ` + "leaving the seed workspace as it is.");
+  }
+  await confineDefaultWorkspace(dir);
+  await fs.mkdir(dir);
+  await confineDefaultWorkspace(dir);
+  const written = [...extracted.entries.keys()];
+  const apply = async () => {
+    await confineDefaultWorkspace(dir);
+    const root = await workspaceRoot(dir);
+    await applyEntries(root, extracted.entries);
+    return removeStaleFiles(root, written, extracted.directories);
+  };
+  const removalWarnings = options.lockHeld ? await apply() : await withWorkspaceLock(dir, apply);
+  return {
+    dir,
+    written,
+    warnings: [...extracted.warnings, ...removalWarnings]
+  };
+}
+async function confineDefaultWorkspace(dir) {
+  const fs = getFileSystem();
+  const rootPath = fs.path.resolve(seedRoot());
+  const target = fs.path.resolve(fs.env.cwd(), dir);
+  if (target !== rootPath && !await namesSeedRoot(target))
+    return;
+  const checked = await insideSeedRoot(target);
+  if (checked.ok)
+    return;
+  throw new Error(`${checked.message} Refusing to write the seed templates into it. ` + checked.instructions);
+}
+async function withWorkspaceLock(dir, work) {
+  const fs = getFileSystem();
+  const [lockError, release] = await catchError(acquireSeedWorkspaceLock(dir, fs));
+  if (lockError || !release) {
+    throw new Error(`Could not lock the seed workspace ${dir} for the refresh: ` + `${lockError?.message ?? "no lock"}. Another deploy or seed may ` + "be using it; wait for it to finish and refresh again.");
+  }
+  try {
+    return await work();
+  } finally {
+    await catchError(release());
+  }
+}
+
+export { isUnsafeSegment, withoutControlBytes, isDotSegment, segmentNameProblem, refreshSeedTemplates };
+
+//# debugId=0E3DA92558B4E64564756E2164756E21

package/dist/tool.js

@@ -1,7 +1,17 @@
 import {
   metadata,
   registerCommands
-} from "./tool-xymb3dsq.js";
+} from "./tool-n35nrs32.js";
+import"./tool-jjxbj28g.js";
+import"./tool-r1ewa0tf.js";
+import"./tool-38ad77wd.js";
+import"./tool-cag2z2d6.js";
+import"./tool-h4f967yd.js";
+import"./tool-rr9fensp.js";
+import"./tool-s04z9t80.js";
+import"./tool-vf2mgth0.js";
+import"./tool-pz9qm3dv.js";
+import"./tool-hdxtgckw.js";
 import"./tool-mpvp5rqs.js";
 import"./tool-1yh8g550.js";
 export {
@@ -9,4 +19,4 @@ export {
   registerCommands
 };
 
-//# debugId=6CE61C21DAD27F3464756E2164756E21
+//# debugId=4E0A5B04996A3AAE64756E2164756E21