@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-XV7NZL4B.js

@@ -0,0 +1,57 @@
+// src/planning/blocker-redaction.ts
+var START_TOKEN = "BLOCKER_CONTEXT:START";
+var END_TOKEN = "BLOCKER_CONTEXT:END";
+var HTML_START_PREFIX = "<!-- ";
+var ESCAPED_START_PREFIX = "\\u003c!-- ";
+var HTML_COMMENT_END = "-->";
+var ESCAPED_COMMENT_END = "--\\u003e";
+function findLastMarkerPrefixIndex(text, markerIndex) {
+  const htmlIdx = text.lastIndexOf(HTML_START_PREFIX, markerIndex);
+  const escapedIdx = text.lastIndexOf(ESCAPED_START_PREFIX, markerIndex);
+  const prefixIdx = Math.max(htmlIdx, escapedIdx);
+  return prefixIdx >= 0 ? prefixIdx : markerIndex;
+}
+function findCommentEndIndex(text, from) {
+  const htmlEnd = text.indexOf(HTML_COMMENT_END, from);
+  const escapedEnd = text.indexOf(ESCAPED_COMMENT_END, from);
+  if (htmlEnd === -1) return escapedEnd;
+  if (escapedEnd === -1) return htmlEnd;
+  return Math.min(htmlEnd, escapedEnd);
+}
+function redactBlockerContext(text) {
+  if (!text.includes(START_TOKEN)) {
+    return text;
+  }
+  let output = "";
+  let cursor = 0;
+  while (cursor < text.length) {
+    const startTokenIdx = text.indexOf(START_TOKEN, cursor);
+    if (startTokenIdx === -1) {
+      output += text.slice(cursor);
+      break;
+    }
+    const blockStart = findLastMarkerPrefixIndex(text, startTokenIdx);
+    output += text.slice(cursor, blockStart);
+    const startCommentEnd = findCommentEndIndex(text, startTokenIdx);
+    if (startCommentEnd === -1) {
+      break;
+    }
+    const searchAfterStart = startCommentEnd + HTML_COMMENT_END.length;
+    const endTokenIdx = text.indexOf(END_TOKEN, searchAfterStart);
+    if (endTokenIdx === -1) {
+      break;
+    }
+    const endCommentEnd = findCommentEndIndex(text, endTokenIdx);
+    if (endCommentEnd === -1) {
+      break;
+    }
+    const isEscapedEnd = text.startsWith(ESCAPED_COMMENT_END, endCommentEnd);
+    cursor = endCommentEnd + (isEscapedEnd ? ESCAPED_COMMENT_END.length : HTML_COMMENT_END.length);
+  }
+  return output;
+}
+
+export {
+  redactBlockerContext
+};
+//# sourceMappingURL=chunk-XV7NZL4B.js.map

package/dist/chunk-XWIZ6B5S.js

@@ -0,0 +1,109 @@
+import {
+  getRuntimeEnv,
+  isRuntimeEnvEnabled
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/output-policy.ts
+function hasFlag(args, shortFlag, longFlag) {
+  return args.includes(shortFlag) || args.includes(longFlag);
+}
+function hasKeyValueFlag(args, key, expectedValue) {
+  const expected = expectedValue.toLowerCase();
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (typeof arg === "string" && arg.startsWith(`${key}=`) && arg.slice(key.length + 1).toLowerCase() === expected) {
+      return true;
+    }
+    if (arg === key) {
+      const next = args[i + 1];
+      if (typeof next === "string" && next.toLowerCase() === expected) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function hasLeadingShortVerbose(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "-v") return true;
+    if (typeof arg !== "string" || !arg.startsWith("-") || arg === "--") return false;
+    if (arg === "--output") i += 1;
+    if (arg === "--color") {
+      const next = args[i + 1]?.toLowerCase();
+      if (next === "true" || next === "false") i += 1;
+    }
+  }
+  return false;
+}
+function resolveOutputPolicyFromArgs(args) {
+  const quietFlag = hasFlag(args, "-q", "--quiet");
+  const verbose = args.includes("--verbose") || hasLeadingShortVerbose(args);
+  const debug = args.includes("--debug") || isRuntimeEnvEnabled("BUILD_DEBUG");
+  const json = args.includes("--json") || args.includes("-j") || hasKeyValueFlag(args, "--output", "json");
+  const noColorFlag = args.includes("--no-color") || hasKeyValueFlag(args, "--color", "false");
+  const noColorEnv = isRuntimeEnvEnabled("NO_COLOR") || getRuntimeEnv("FORCE_COLOR") === "0";
+  const quiet = quietFlag || json;
+  const level = quiet ? "quiet" : debug ? "debug" : verbose ? "verbose" : "normal";
+  return {
+    quiet,
+    verbose,
+    debug,
+    json,
+    noColor: noColorFlag || json || noColorEnv,
+    level
+  };
+}
+function outputPolicyToEnv(policy) {
+  const overrides = {};
+  if (policy.verbose) {
+    overrides.BUILD_VERBOSE = "1";
+  }
+  if (policy.debug) {
+    overrides.BUILD_DEBUG = "1";
+  }
+  if (policy.quiet) {
+    overrides.BUILD_QUIET = "1";
+  }
+  if (policy.json) {
+    overrides.BUILD_OUTPUT_JSON = "1";
+  }
+  if (policy.noColor) {
+    overrides.NO_COLOR = "1";
+    overrides.FORCE_COLOR = "0";
+  }
+  return overrides;
+}
+function isQuietOutputRequested() {
+  return isRuntimeEnvEnabled("BUILD_QUIET") || isJsonOutputRequested();
+}
+function isJsonOutputRequested() {
+  return isRuntimeEnvEnabled("BUILD_OUTPUT_JSON") || isRuntimeEnvEnabled("BUILD_JSON_OUTPUT");
+}
+function isVerboseOutputRequested() {
+  return isRuntimeEnvEnabled("BUILD_VERBOSE");
+}
+function isDebugOutputRequested() {
+  return isRuntimeEnvEnabled("BUILD_DEBUG");
+}
+function getOutputLevel() {
+  if (isQuietOutputRequested()) return "quiet";
+  if (isDebugOutputRequested()) return "debug";
+  if (isVerboseOutputRequested()) return "verbose";
+  return "normal";
+}
+function shouldShowLifecycleDiagnostics() {
+  return isVerboseOutputRequested() || isDebugOutputRequested();
+}
+
+export {
+  resolveOutputPolicyFromArgs,
+  outputPolicyToEnv,
+  isQuietOutputRequested,
+  isJsonOutputRequested,
+  isVerboseOutputRequested,
+  isDebugOutputRequested,
+  getOutputLevel,
+  shouldShowLifecycleDiagnostics
+};
+//# sourceMappingURL=chunk-XWIZ6B5S.js.map

package/dist/chunk-XWLIKOBX.js

@@ -0,0 +1,240 @@
+// src/cli/commands/package.ts
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+var REQUIRED_RUNTIME_PATHS = [
+  "dist",
+  "templates",
+  "package.json",
+  "schemas",
+  ".build-project/providers",
+  ".build-project/providers/catalog.json",
+  "scripts/assert-node-runtime.mjs",
+  "scripts/preflight-native.mjs",
+  "scripts/write-node-launcher.sh",
+  "scripts/setup-git-hooks.mjs",
+  "scripts/sync.sh",
+  "src/resources",
+  ".nvmrc"
+];
+var LOCKFILE_PATHS = ["package-lock.json", "npm-shrinkwrap.json"];
+var OPTIONAL_RUNTIME_PATHS = [
+  "README.md",
+  "INSTALL.md",
+  "LICENSE",
+  "CHANGELOG.md",
+  "CONTRIBUTING.md",
+  "CODE_OF_CONDUCT.md",
+  // Optional BB visual experience package used by `build provider setup --bb`.
+  "integrations/bb-plugin-build"
+];
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isSameOrAncestorPath(candidateAncestor, targetPath) {
+  const relative = path.relative(candidateAncestor, targetPath);
+  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function isBroadOutputPath(outputRoot) {
+  const parsed = path.parse(outputRoot);
+  if (outputRoot === parsed.root) return true;
+  const home = os.homedir();
+  return Boolean(home) && outputRoot === path.resolve(home);
+}
+async function isExistingLocalDistPackage(outputRoot) {
+  const manifest = await readJsonFile(
+    path.join(outputRoot, "build-package.json")
+  );
+  const isBuildBundle = manifest?.name === "@ebrindley/build";
+  return isBuildBundle && manifest?.env?.BUILD_PACKAGE_ROOT === outputRoot;
+}
+async function validateOutputRootForWrite(input) {
+  const { outputRoot, sourceRoot, force } = input;
+  if (isBroadOutputPath(outputRoot)) {
+    throw new Error(`Refusing to use broad package output path: ${outputRoot}`);
+  }
+  if (isSameOrAncestorPath(outputRoot, sourceRoot)) {
+    throw new Error(
+      `Refusing to use package output path that is the Build source root or one of its ancestors: ${outputRoot}`
+    );
+  }
+  if (force && await pathExists(outputRoot) && !await isExistingLocalDistPackage(outputRoot)) {
+    throw new Error(
+      `Refusing to replace non-Build local-dist directory: ${outputRoot}. Choose an empty/new output path or remove it manually after inspection.`
+    );
+  }
+}
+async function readJsonFile(targetPath) {
+  try {
+    return JSON.parse(await fs.readFile(targetPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function findPackageRoot(startFile) {
+  let current = path.dirname(startFile);
+  while (true) {
+    const packageJsonPath = path.join(current, "package.json");
+    const packageJson = await readJsonFile(packageJsonPath);
+    if (packageJson?.name === "@ebrindley/build") {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      throw new Error("Unable to resolve Build package root");
+    }
+    current = parent;
+  }
+}
+async function resolveRuntimePaths(sourceRoot) {
+  const paths = [];
+  for (const relativePath of REQUIRED_RUNTIME_PATHS) {
+    if (!await pathExists(path.join(sourceRoot, relativePath))) {
+      return { missing: relativePath };
+    }
+    paths.push(relativePath);
+  }
+  for (const lockfile of LOCKFILE_PATHS) {
+    if (await pathExists(path.join(sourceRoot, lockfile))) {
+      paths.push(lockfile);
+      return { paths };
+    }
+  }
+  return { missing: LOCKFILE_PATHS.join(" or ") };
+}
+async function copyRequiredPath(sourceRoot, outputRoot, relativePath) {
+  const source = path.join(sourceRoot, relativePath);
+  const destination = path.join(outputRoot, relativePath);
+  if (!await pathExists(source)) {
+    throw new Error(`Required runtime path is missing: ${relativePath}`);
+  }
+  await fs.mkdir(path.dirname(destination), { recursive: true });
+  await fs.cp(source, destination, {
+    recursive: true,
+    force: true,
+    errorOnExist: false,
+    preserveTimestamps: true,
+    verbatimSymlinks: true
+  });
+}
+async function copyOptionalPath(sourceRoot, outputRoot, relativePath) {
+  const source = path.join(sourceRoot, relativePath);
+  if (!await pathExists(source)) return;
+  await copyRequiredPath(sourceRoot, outputRoot, relativePath);
+}
+function formatTextReport(manifest) {
+  const dependencyLine = manifest.dependencyMode.type === "copied-node-modules" ? `Dependencies: copied to ${manifest.dependencyMode.path}` : `Dependencies: install with \`${manifest.dependencyMode.command}\``;
+  return [
+    `Package root: ${manifest.packageRoot}`,
+    `Entry: ${manifest.entry}`,
+    `Set: BUILD_PACKAGE_ROOT=${manifest.packageRoot}`,
+    dependencyLine,
+    `Manifest: ${path.join(manifest.packageRoot, "build-package.json")}`
+  ].join("\n");
+}
+async function createLocalDistPackage(options, deps = {}) {
+  const outputRoot = path.resolve(options.output);
+  const moduleUrl = deps.moduleUrl ?? import.meta.url;
+  const sourceRoot = await findPackageRoot(fileURLToPath(moduleUrl));
+  await validateOutputRootForWrite({
+    outputRoot,
+    sourceRoot,
+    force: options.force
+  });
+  if (await pathExists(outputRoot) && !options.force) {
+    throw new Error(`Output already exists: ${outputRoot}. Re-run with --force to replace it.`);
+  }
+  const runtime = await resolveRuntimePaths(sourceRoot);
+  if ("missing" in runtime) {
+    throw new Error(`Required runtime path is missing: ${runtime.missing}`);
+  }
+  if (options.force) {
+    await fs.rm(outputRoot, { recursive: true, force: true });
+  }
+  await fs.mkdir(outputRoot, { recursive: true });
+  for (const relativePath of runtime.paths) {
+    await copyRequiredPath(sourceRoot, outputRoot, relativePath);
+  }
+  for (const relativePath of OPTIONAL_RUNTIME_PATHS) {
+    await copyOptionalPath(sourceRoot, outputRoot, relativePath);
+  }
+  const packageJson = await readJsonFile(path.join(sourceRoot, "package.json")) ?? {};
+  const buildMeta = await readJsonFile(path.join(sourceRoot, "dist/.build-meta.json"));
+  const shouldCopyNodeModules = options.copyNodeModules !== false;
+  const sourceNodeModules = path.join(sourceRoot, "node_modules");
+  const outputNodeModules = path.join(outputRoot, "node_modules");
+  let dependencyMode;
+  if (shouldCopyNodeModules && await pathExists(sourceNodeModules)) {
+    await fs.cp(sourceNodeModules, outputNodeModules, {
+      recursive: true,
+      force: true,
+      errorOnExist: false,
+      preserveTimestamps: true,
+      verbatimSymlinks: true
+    });
+    dependencyMode = { type: "copied-node-modules", path: outputNodeModules };
+  } else {
+    dependencyMode = {
+      type: "install-required",
+      command: "npm install --omit=dev"
+    };
+  }
+  const manifest = {
+    name: packageJson.name ?? "@ebrindley/build",
+    version: packageJson.version ?? "unknown",
+    packageRoot: outputRoot,
+    entry: path.join(outputRoot, "dist/entry.js"),
+    createdAt: (deps.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+    sourcePackageRoot: sourceRoot,
+    sourceGitHead: buildMeta?.gitHead ?? null,
+    dependencyMode,
+    env: {
+      BUILD_PACKAGE_ROOT: outputRoot
+    }
+  };
+  await fs.writeFile(
+    path.join(outputRoot, "build-package.json"),
+    `${JSON.stringify(manifest, null, 2)}
+`,
+    "utf8"
+  );
+  await fs.writeFile(
+    path.join(outputRoot, "BUILD_PACKAGE_ROOT.env"),
+    `BUILD_PACKAGE_ROOT=${outputRoot}
+`,
+    "utf8"
+  );
+  return manifest;
+}
+function createPackageCommand() {
+  const command = new Command("package").description("Create local Build runtime packages");
+  command.command("local-dist").description(
+    "Create a frozen runnable local dist bundle for local verification and release checks"
+  ).requiredOption("--output <dir>", "Output directory for the local dist bundle").option("--force", "Replace output directory if it already exists").option("--json", "Print package metadata as JSON").option(
+    "--no-copy-node-modules",
+    "Do not copy node_modules; write install instructions instead"
+  ).action(async (options) => {
+    const manifest = await createLocalDistPackage(options);
+    if (options.json) {
+      process.stdout.write(`${JSON.stringify(manifest, null, 2)}
+`);
+    } else {
+      process.stdout.write(`${formatTextReport(manifest)}
+`);
+    }
+  });
+  return command;
+}
+
+export {
+  createLocalDistPackage,
+  createPackageCommand
+};
+//# sourceMappingURL=chunk-XWLIKOBX.js.map

package/dist/chunk-XZOXEIN4.js

@@ -0,0 +1,156 @@
+import {
+  SYSTEM_WRITE_PATH_PREFIXES,
+  isSystemWritePath
+} from "./chunk-RBBTBCHX.js";
+import {
+  isDependencyManifestPath,
+  isGeneratedLockfilePath,
+  manifestKind
+} from "./chunk-D4VJFCGZ.js";
+import {
+  companionTestCandidatePaths
+} from "./chunk-RPIMAMV7.js";
+
+// src/automation/allowlist-utils.ts
+import { existsSync, readdirSync } from "fs";
+import path from "path";
+
+// src/automation/protected-manifest-paths.ts
+var PROTECTED_MANIFESTS_ENTRY = "<protected-manifests>";
+var EXTRA_PROTECTED_ROOT_FILES = /* @__PURE__ */ new Set([
+  "requirements.txt",
+  "Directory.Build.props"
+]);
+function isProtectedManifestPath(normalizedPath) {
+  if (normalizedPath.includes("/")) return false;
+  return manifestKind(normalizedPath) !== null || isDependencyManifestPath(normalizedPath) || isGeneratedLockfilePath(normalizedPath) || EXTRA_PROTECTED_ROOT_FILES.has(normalizedPath);
+}
+
+// src/automation/allowlist-utils.ts
+var adjacentAllowlistExpansionCache = /* @__PURE__ */ new Map();
+function isPathAllowed(changedPath, allowlist) {
+  const normalizedChanged = normalizePath(changedPath);
+  for (const allowed of allowlist) {
+    const normalizedAllowed = normalizePath(allowed);
+    if (normalizedChanged === normalizedAllowed) {
+      return true;
+    }
+    if (normalizedAllowed.endsWith("/") && normalizedChanged.startsWith(normalizedAllowed)) {
+      return true;
+    }
+    if (normalizedChanged.endsWith("/") && normalizedAllowed.startsWith(normalizedChanged)) {
+      return true;
+    }
+    const parentDir = normalizedAllowed.includes("/") ? `${normalizedAllowed.slice(0, normalizedAllowed.lastIndexOf("/") + 1)}` : "";
+    if (parentDir.length > 0 && normalizedChanged === parentDir) {
+      return true;
+    }
+  }
+  return false;
+}
+function isPathDenied(changedPath, denylist) {
+  const normalizedChanged = normalizePath(changedPath);
+  for (const denied of denylist) {
+    const normalizedDenied = normalizePath(denied);
+    if (normalizedDenied === PROTECTED_MANIFESTS_ENTRY && isProtectedManifestPath(normalizedChanged)) {
+      return true;
+    }
+    if (normalizedChanged === normalizedDenied) {
+      return true;
+    }
+    if (normalizedDenied.endsWith("/") && normalizedChanged.startsWith(normalizedDenied)) {
+      return true;
+    }
+  }
+  return false;
+}
+function normalizePath(filePath) {
+  const cleaned = filePath.replace(/^\.\//, "");
+  return path.normalize(cleaned).replace(/\\/g, "/");
+}
+function filterAllowedFiles(changedFiles, allowlist) {
+  return changedFiles.filter((file) => isPathAllowed(file, allowlist));
+}
+function findAllowlistViolations(changedFiles, allowlist) {
+  return changedFiles.filter((file) => !isPathAllowed(file, allowlist));
+}
+function buildLayoutCompanions(entry, repoRoot) {
+  const basename = entry.replace(/\.ts$/, "").split("/").pop();
+  if (!basename) return [];
+  const relPath = entry.slice(4).replace(/\.ts$/, "");
+  const dir = entry.slice(0, entry.lastIndexOf("/") + 1);
+  const candidates = [];
+  if (relPath.startsWith("cli/commands/")) {
+    candidates.push(`tests/cli/${basename}-command.test.ts`);
+    candidates.push(`tests/unit/cli/commands/${basename}-command-help.test.ts`);
+  }
+  if (relPath.startsWith("cli/")) {
+    candidates.push(`tests/unit/cli/${basename}.test.ts`);
+  }
+  const unitDir = path.resolve(repoRoot, "tests", "unit", path.dirname(relPath));
+  if (existsSync(unitDir)) {
+    try {
+      for (const candidate of readdirSync(unitDir)) {
+        if (candidate.startsWith(`${basename}-`) && candidate.endsWith(".test.ts")) {
+          candidates.push(path.posix.join("tests", "unit", path.dirname(relPath), candidate));
+        }
+      }
+    } catch {
+    }
+  }
+  candidates.push(
+    ...[`${dir}types.ts`, `${dir}interfaces.ts`, `${dir}i-${basename}.ts`].filter(
+      (candidate) => candidate !== entry
+    )
+  );
+  return candidates;
+}
+function expandAllowlistWithAdjacentTests(allowlist, repoRoot = process.cwd()) {
+  const cacheKey = `${path.resolve(repoRoot)}\0${allowlist.join("\0")}`;
+  const cached = adjacentAllowlistExpansionCache.get(cacheKey);
+  if (cached) {
+    return [...cached];
+  }
+  const expanded = [...allowlist];
+  const seen = new Set(allowlist);
+  const exists = (candidate) => existsSync(path.resolve(repoRoot, candidate));
+  for (const entry of allowlist) {
+    const candidates = companionTestCandidatePaths(entry).filter(exists);
+    if (entry.endsWith(".ts") && entry.startsWith("src/")) {
+      candidates.push(...buildLayoutCompanions(entry, repoRoot).filter(exists));
+    }
+    for (const candidate of candidates) {
+      if (!seen.has(candidate)) {
+        seen.add(candidate);
+        expanded.push(candidate);
+      }
+    }
+  }
+  adjacentAllowlistExpansionCache.set(cacheKey, expanded);
+  return [...expanded];
+}
+function findDenylistViolations(changedFiles, denylist) {
+  return changedFiles.filter((file) => isPathDenied(file, denylist));
+}
+function isAllowlistEmpty(allowlist) {
+  return !allowlist || allowlist.length === 0;
+}
+var SYSTEM_WRITE_PATHS = SYSTEM_WRITE_PATH_PREFIXES;
+function isSystemWritePath2(filePath) {
+  return isSystemWritePath(filePath);
+}
+
+export {
+  PROTECTED_MANIFESTS_ENTRY,
+  isPathAllowed,
+  isPathDenied,
+  normalizePath,
+  filterAllowedFiles,
+  findAllowlistViolations,
+  expandAllowlistWithAdjacentTests,
+  findDenylistViolations,
+  isAllowlistEmpty,
+  SYSTEM_WRITE_PATHS,
+  isSystemWritePath2 as isSystemWritePath
+};
+//# sourceMappingURL=chunk-XZOXEIN4.js.map