@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-NXZ3DURF.js

@@ -0,0 +1,257 @@
+// src/core/cleanup/provider-temp-cleanup.ts
+import { lstat, readdir, realpath, rm, rmdir, stat } from "fs/promises";
+import { join, resolve } from "path";
+var LARGE_RECLAMATION_THRESHOLD_BYTES = 1024 * 1024 * 1024;
+var TOP_OFFENDERS_LIMIT = 10;
+function defaultProviderTempRoots() {
+  const uid = process.getuid?.() ?? 501;
+  const roots = [];
+  roots.push(`/private/tmp/claude-${uid}`);
+  roots.push("/private/tmp/claude-mcp-npm-cache");
+  return roots;
+}
+var ALLOWED_ROOT_PREFIXES = [
+  "/tmp",
+  "/private/tmp",
+  "/var/folders",
+  "/private/var/folders"
+];
+function isAllowedRootPrefix(path, options = {}) {
+  return ALLOWED_ROOT_PREFIXES.some(
+    (prefix) => options.allowExactRoot && path === prefix || path.startsWith(`${prefix}/`)
+  );
+}
+async function validateProviderTempRoot(root, options = {}) {
+  const resolved = resolve(root);
+  if (!isAllowedRootPrefix(resolved, options)) {
+    return {
+      valid: false,
+      resolved,
+      reason: `Refused to operate on root outside ${ALLOWED_ROOT_PREFIXES.join(", ")}`
+    };
+  }
+  try {
+    const rootStats = await lstat(resolved);
+    if (rootStats.isSymbolicLink()) {
+      return {
+        valid: false,
+        resolved,
+        reason: "Refused to operate on symlinked root"
+      };
+    }
+    const canonical = await realpath(resolved);
+    if (!isAllowedRootPrefix(canonical, options)) {
+      return {
+        valid: false,
+        resolved,
+        reason: `Refused to operate on root resolving outside ${ALLOWED_ROOT_PREFIXES.join(", ")}`
+      };
+    }
+  } catch {
+  }
+  return { valid: true, resolved };
+}
+async function walkDirectory(dir, nowMs) {
+  const files = [];
+  const errors = [];
+  async function walk(currentDir) {
+    let entries;
+    try {
+      entries = await readdir(currentDir);
+    } catch (err) {
+      errors.push(`readdir ${currentDir}: ${err instanceof Error ? err.message : String(err)}`);
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join(currentDir, entry);
+      try {
+        const stats = await lstat(fullPath);
+        if (stats.isSymbolicLink()) {
+          continue;
+        }
+        if (stats.isDirectory()) {
+          await walk(fullPath);
+          continue;
+        }
+        if (stats.isFile()) {
+          const ageMs = nowMs - stats.mtimeMs;
+          const ageHours = ageMs / (1e3 * 60 * 60);
+          files.push({
+            path: fullPath,
+            sizeBytes: stats.size,
+            ageHours,
+            isDirectory: false
+          });
+        }
+      } catch (err) {
+        errors.push(`stat ${fullPath}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+  await walk(dir);
+  return { files, errors };
+}
+async function removeEmptyDirs(dir) {
+  let removed = 0;
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return 0;
+  }
+  for (const entry of entries) {
+    const fullPath = join(dir, entry);
+    try {
+      const stats = await lstat(fullPath);
+      if (stats.isDirectory() && !stats.isSymbolicLink()) {
+        removed += await removeEmptyDirs(fullPath);
+      }
+    } catch {
+    }
+  }
+  try {
+    const remaining = await readdir(dir);
+    if (remaining.length === 0) {
+      await rmdir(dir);
+      removed++;
+    }
+  } catch {
+  }
+  return removed;
+}
+async function scanRoot(root, maxAgeHours) {
+  const validation = await validateProviderTempRoot(root);
+  const resolved = validation.resolved;
+  if (!validation.valid) {
+    return {
+      result: {
+        root: resolved,
+        exists: false,
+        totalFiles: 0,
+        totalSizeBytes: 0,
+        deletableFiles: 0,
+        deletableSizeBytes: 0,
+        topOffenders: [],
+        skipped: 0
+      },
+      files: [],
+      errors: [validation.reason ?? "Invalid root"]
+    };
+  }
+  try {
+    await stat(resolved);
+  } catch {
+    return {
+      result: {
+        root: resolved,
+        exists: false,
+        totalFiles: 0,
+        totalSizeBytes: 0,
+        deletableFiles: 0,
+        deletableSizeBytes: 0,
+        topOffenders: [],
+        skipped: 0
+      },
+      files: [],
+      errors: []
+    };
+  }
+  const nowMs = Date.now();
+  const { files, errors } = await walkDirectory(resolved, nowMs);
+  const totalFiles = files.length;
+  const totalSizeBytes = files.reduce((sum, f) => sum + f.sizeBytes, 0);
+  const deletable = files.filter((f) => f.ageHours >= maxAgeHours);
+  const deletableFiles = deletable.length;
+  const deletableSizeBytes = deletable.reduce((sum, f) => sum + f.sizeBytes, 0);
+  const skipped = totalFiles - deletableFiles;
+  const topOffenders = [...files].sort((a, b) => b.sizeBytes - a.sizeBytes).slice(0, TOP_OFFENDERS_LIMIT);
+  return {
+    result: {
+      root: resolved,
+      exists: true,
+      totalFiles,
+      totalSizeBytes,
+      deletableFiles,
+      deletableSizeBytes,
+      topOffenders,
+      skipped
+    },
+    files,
+    errors
+  };
+}
+async function cleanProviderTemp(config, options) {
+  const report = {
+    mode: options.dryRun ? "dry-run" : "executed",
+    roots: [],
+    totals: {
+      scannedFiles: 0,
+      deletedFiles: 0,
+      freedBytes: 0,
+      skippedFiles: 0
+    },
+    errors: []
+  };
+  for (const root of config.roots) {
+    const validation = await validateProviderTempRoot(root);
+    if (!validation.valid) {
+      report.errors.push(`${validation.reason}: ${validation.resolved}`);
+      continue;
+    }
+    const { result, files, errors } = await scanRoot(validation.resolved, config.maxAgeHours);
+    report.roots.push(result);
+    report.errors.push(...errors);
+    report.totals.scannedFiles += result.totalFiles;
+    report.totals.skippedFiles += result.skipped;
+    if (!result.exists || result.deletableFiles === 0) {
+      continue;
+    }
+    if (options.dryRun) {
+      report.totals.deletedFiles += result.deletableFiles;
+      report.totals.freedBytes += result.deletableSizeBytes;
+      continue;
+    }
+    const deletable = files.filter((f) => f.ageHours >= config.maxAgeHours);
+    let deletedCount = 0;
+    let freedBytes = 0;
+    for (const file of deletable) {
+      try {
+        await rm(file.path, { force: true });
+        deletedCount++;
+        freedBytes += file.sizeBytes;
+      } catch (err) {
+        report.errors.push(
+          `delete ${file.path}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    try {
+      const entries = await readdir(validation.resolved);
+      for (const entry of entries) {
+        const subdir = join(validation.resolved, entry);
+        const stats = await lstat(subdir);
+        if (stats.isDirectory() && !stats.isSymbolicLink()) {
+          await removeEmptyDirs(subdir);
+        }
+      }
+    } catch {
+    }
+    report.totals.deletedFiles += deletedCount;
+    report.totals.freedBytes += freedBytes;
+  }
+  if (!options.quiet && !options.dryRun && report.totals.freedBytes >= LARGE_RECLAMATION_THRESHOLD_BYTES) {
+    const gbFreed = (report.totals.freedBytes / (1024 * 1024 * 1024)).toFixed(1);
+    report.errors.push(
+      `WARNING: Large reclamation detected (${gbFreed} GB freed). Check provider temp generation rate.`
+    );
+  }
+  return report;
+}
+
+export {
+  defaultProviderTempRoots,
+  validateProviderTempRoot,
+  scanRoot,
+  cleanProviderTemp
+};
+//# sourceMappingURL=chunk-NXZ3DURF.js.map

package/dist/chunk-O26L6F7F.js

@@ -0,0 +1,209 @@
+import {
+  KEYS
+} from "./chunk-7VRJHTGZ.js";
+
+// src/utils/fuzzy-match.ts
+function levenshteinDistance(a, b) {
+  const prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  const curr = new Array(b.length + 1);
+  for (let i = 1; i <= a.length; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      curr[j] = a[i - 1] === b[j - 1] ? prev[j - 1] : 1 + Math.min(prev[j], curr[j - 1], prev[j - 1]);
+    }
+    for (let j = 0; j <= b.length; j++) prev[j] = curr[j];
+  }
+  return prev[b.length];
+}
+function findClosestMatch(input, candidates) {
+  const inputLower = input.toLowerCase();
+  for (const candidate of candidates) {
+    if (candidate.toLowerCase() === inputLower) return candidate;
+  }
+  if (inputLower.length >= 3) {
+    let prefixMatch;
+    let prefixMatchLen = Infinity;
+    for (const candidate of candidates) {
+      const candidateLower = candidate.toLowerCase();
+      if (candidateLower.startsWith(inputLower)) {
+        if (candidate.length < prefixMatchLen) {
+          prefixMatchLen = candidate.length;
+          prefixMatch = candidate;
+        }
+      }
+    }
+    if (prefixMatch) return prefixMatch;
+  }
+  let closest;
+  let minDistance = Infinity;
+  for (const candidate of candidates) {
+    const distance = levenshteinDistance(inputLower, candidate.toLowerCase());
+    if (distance < minDistance && distance <= 2) {
+      minDistance = distance;
+      closest = candidate;
+    }
+  }
+  return closest;
+}
+
+// src/core/config/registry/dynamic-keys.ts
+var DYNAMIC_KEYS = [
+  //  Per-command idle timeouts
+  // Source: src/core/providers/shared/base-runner.ts
+  //   process.env[`BUILD_IDLE_WARN_${commandName}_MS`]
+  {
+    pattern: /^BUILD_IDLE_WARN_[A-Z][A-Z0-9_]*_MS$/,
+    extract: (name) => {
+      const m = name.match(/^BUILD_IDLE_WARN_([A-Z][A-Z0-9_]*)_MS$/);
+      if (!m || m[1] === void 0) return null;
+      return { command: m[1] };
+    },
+    category: "provider",
+    status: "active",
+    description: "Per-command idle warning threshold: BUILD_IDLE_WARN_<CMD>_MS",
+    type: "number"
+  },
+  {
+    pattern: /^BUILD_IDLE_KILL_[A-Z][A-Z0-9_]*_MS$/,
+    extract: (name) => {
+      const m = name.match(/^BUILD_IDLE_KILL_([A-Z][A-Z0-9_]*)_MS$/);
+      if (!m || m[1] === void 0) return null;
+      return { command: m[1] };
+    },
+    category: "provider",
+    status: "active",
+    description: "Per-command idle kill threshold: BUILD_IDLE_KILL_<CMD>_MS",
+    type: "number"
+  },
+  //  Per-provider timeout overrides
+  // Source: src/core/timeout/timeout-config.ts
+  //   `BUILD_TIMEOUT_${normalizedProvider.toUpperCase()}_${mode.toUpperCase()}`
+  //   `BUILD_TIMEOUT_DEFAULT_${mode.toUpperCase()}`
+  // Modes observed: LOCAL, CLOUD, API, REMOTE, MS, and any future mode string.
+  {
+    pattern: /^BUILD_TIMEOUT_[A-Z][A-Z0-9_]*_[A-Z][A-Z0-9]*$/,
+    extract: (name) => {
+      const m = name.match(/^BUILD_TIMEOUT_([A-Z][A-Z0-9_]*)_([A-Z][A-Z0-9]*)$/);
+      if (!m || m[1] === void 0 || m[2] === void 0) return null;
+      return { provider: m[1], mode: m[2] };
+    },
+    category: "provider",
+    status: "active",
+    description: "Per-provider/mode timeout override (ms): BUILD_TIMEOUT_<PROVIDER>_<MODE> or BUILD_TIMEOUT_DEFAULT_<MODE>",
+    type: "number"
+  },
+  //  Per-provider timeout from provider-timeout.ts
+  // Source: src/core/providers/shared/provider-timeout.ts
+  //   `BUILD_TIMEOUT_${providerId.toUpperCase()}_MS`
+  // This is a subset of the pattern above; the combined pattern already covers it.
+  //  Per-provider sandbox toggles
+  // Source: src/core/sandbox/index.ts
+  //   process.env[`BUILD_SANDBOX_${normalizedName}_ENABLED`]
+  //   process.env[`BUILD_SANDBOX_${normalizedId}_ENABLED`]
+  {
+    pattern: /^BUILD_SANDBOX_[A-Z][A-Z0-9_]*_ENABLED$/,
+    extract: (name) => {
+      const m = name.match(/^BUILD_SANDBOX_([A-Z][A-Z0-9_]*)_ENABLED$/);
+      if (!m || m[1] === void 0) return null;
+      return { provider: m[1] };
+    },
+    category: "sandbox",
+    status: "active",
+    description: "Per-provider sandbox enable toggle: BUILD_SANDBOX_<PROVIDER>_ENABLED",
+    type: "boolean"
+  },
+  //  Per-provider execution policy enforcement
+  // Source: src/orchestrator/execution-policy.ts
+  //   `BUILD_EXECUTION_POLICY_ENFORCE_${provider.toUpperCase()}`
+  {
+    pattern: /^BUILD_EXECUTION_POLICY_ENFORCE_[A-Z][A-Z0-9_]*$/,
+    extract: (name) => {
+      const m = name.match(/^BUILD_EXECUTION_POLICY_ENFORCE_([A-Z][A-Z0-9_]*)$/);
+      if (!m || m[1] === void 0) return null;
+      return { provider: m[1] };
+    },
+    category: "orchestrator",
+    status: "active",
+    description: "Per-provider execution policy enforcement toggle: BUILD_EXECUTION_POLICY_ENFORCE_<PROVIDER>",
+    type: "boolean"
+  },
+  //  Per-provider config overrides
+  // Source: src/core/config/provider-registry.ts
+  //   BUILD_PROVIDER_<ID>_<KEY>=value (e.g. BUILD_PROVIDER_CODEX_TIMEOUT_MS,
+  //   BUILD_PROVIDER_CLAUDE_ENABLED, BUILD_PROVIDER_GEMINI_MODELS_DEFAULT).
+  // Static REGISTRY entries that begin with BUILD_PROVIDER_ are checked
+  // first by isRecognizedEnvVar; this fallback recognizes the dynamic
+  // <PROVIDER>_<KEY> shape so legitimate overrides aren't flagged. The
+  // provider/key boundary is registry-dependent because both may contain
+  // underscores; ProviderRegistry resolves the longest registered prefix.
+  {
+    pattern: /^BUILD_PROVIDER_[A-Z0-9][A-Z0-9_-]*_[A-Z][A-Z0-9_]*$/,
+    extract: (name) => {
+      const m = name.match(/^BUILD_PROVIDER_([A-Z0-9][A-Z0-9_-]*_[A-Z][A-Z0-9_]*)$/);
+      if (!m || m[1] === void 0) return null;
+      return { providerAndKey: m[1] };
+    },
+    category: "provider",
+    status: "active",
+    description: "Per-provider config override: BUILD_PROVIDER_<ID>_<KEY>",
+    type: "string"
+  }
+];
+
+// src/core/config/env-var-registry.ts
+var REGISTRY = Object.fromEntries(
+  Object.entries(KEYS).map(([name, spec]) => [
+    name,
+    {
+      category: spec.category,
+      status: spec.status,
+      description: spec.description,
+      ...spec.replacement !== void 0 ? { replacement: spec.replacement } : {}
+    }
+  ])
+);
+function isRecognizedEnvVar(name) {
+  if (REGISTRY[name]) return true;
+  return DYNAMIC_KEYS.some((spec) => spec.pattern.test(name));
+}
+function getEnvVarEntry(name) {
+  return REGISTRY[name];
+}
+function closestRegisteredKeys(unknown, maxDist, limit) {
+  const candidates = [];
+  for (const name of Object.keys(REGISTRY)) {
+    if (Math.abs(unknown.length - name.length) > maxDist) continue;
+    const dist = levenshteinDistance(unknown, name);
+    if (dist <= maxDist) candidates.push({ name, dist });
+  }
+  candidates.sort((a, b) => a.dist - b.dist);
+  return candidates.slice(0, limit).map((c) => c.name);
+}
+function validateEnvironmentVars() {
+  const unrecognized = [];
+  for (const key of Object.keys(process.env)) {
+    if (!key.startsWith("BUILD_")) continue;
+    if (!isRecognizedEnvVar(key) && closestRegisteredKeys(key, 2, 3).length > 0) {
+      unrecognized.push(key);
+    }
+  }
+  if (process.env.BUILD_STRICT_ENV === "1" && unrecognized.length > 0) {
+    for (const key of unrecognized) {
+      const suggestions = closestRegisteredKeys(key, 2, 3);
+      console.warn(
+        `[build] BUILD_STRICT_ENV: unrecognized env var: ${key} (did you mean: ${suggestions.join(", ")}?)`
+      );
+    }
+  }
+  return unrecognized;
+}
+
+export {
+  levenshteinDistance,
+  findClosestMatch,
+  isRecognizedEnvVar,
+  getEnvVarEntry,
+  closestRegisteredKeys,
+  validateEnvironmentVars
+};
+//# sourceMappingURL=chunk-O26L6F7F.js.map

package/dist/chunk-O5RRIUEP.js

@@ -0,0 +1,124 @@
+import {
+  NO_REPLACEMENT_COMPAT_ROOTS,
+  getCanonicalCompatPath
+} from "./chunk-NRFRY3GE.js";
+import {
+  isJsonOutputRequested,
+  isQuietOutputRequested
+} from "./chunk-XWIZ6B5S.js";
+
+// src/cli/utils/compatibility-notice.ts
+var STRUCTURED_OUTPUT_FLAGS = /* @__PURE__ */ new Set([
+  "--json",
+  "-j",
+  "--jsonl",
+  "--csv",
+  "--ndjson",
+  "--machine"
+]);
+function getDefaultRuntime() {
+  return {
+    stdoutIsTTY: process.stdout.isTTY,
+    stderrIsTTY: process.stderr.isTTY,
+    writeStderr: (text) => process.stderr.write(text)
+  };
+}
+function argvHasStructuredOutput(argv) {
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (!arg) continue;
+    if (STRUCTURED_OUTPUT_FLAGS.has(arg)) {
+      return true;
+    }
+    if (arg.startsWith("--output=")) {
+      const value = arg.slice("--output=".length).toLowerCase();
+      if (value === "json" || value === "jsonl" || value === "csv" || value === "ndjson") {
+        return true;
+      }
+    }
+    if (arg === "--output") {
+      const next = argv[i + 1];
+      if (typeof next === "string") {
+        const value = next.toLowerCase();
+        if (value === "json" || value === "jsonl" || value === "csv" || value === "ndjson") {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function shouldSuppressCompatibilityNotice(argv = process.argv, env = process.env, runtime = getDefaultRuntime()) {
+  if (isJsonOutputRequested() || isQuietOutputRequested()) {
+    return true;
+  }
+  if (env.BUILD_OUTPUT_JSON === "1" || env.BUILD_JSON_OUTPUT === "1") {
+    return true;
+  }
+  if (env.BUILD_QUIET === "1") {
+    return true;
+  }
+  if (argvHasStructuredOutput(argv)) {
+    return true;
+  }
+  if (runtime.stdoutIsTTY !== true || runtime.stderrIsTTY !== true) {
+    return true;
+  }
+  return false;
+}
+function formatNoReplacementNotice(legacyRoot, entry) {
+  if (entry.kind === "internal") {
+    return `Note: 'build ${legacyRoot}' is an internal helper for Build-generated workflows and has no replacement; do not call it directly.`;
+  }
+  return entry.closest ? `Note: 'build ${legacyRoot}' is retired and will be removed; use 'build ${entry.closest}'.` : `Note: 'build ${legacyRoot}' will be removed; there is no replacement.`;
+}
+function maybeEmitCompatibilityNotice(legacyRoot, argv = process.argv, env = process.env, runtime = getDefaultRuntime()) {
+  if (shouldSuppressCompatibilityNotice(argv, env, runtime)) {
+    return;
+  }
+  const noReplacement = NO_REPLACEMENT_COMPAT_ROOTS[legacyRoot];
+  if (noReplacement) {
+    runtime.writeStderr?.(`${formatNoReplacementNotice(legacyRoot, noReplacement)}
+`);
+    return;
+  }
+  const canonical = getCanonicalCompatPath(legacyRoot);
+  if (!canonical) {
+    return;
+  }
+  if (legacyRoot === "do") {
+    return;
+  }
+  runtime.writeStderr?.(
+    `Note: 'build ${legacyRoot}' remains available; prefer 'build ${canonical}'.
+`
+  );
+}
+function maybeEmitDeprecationNotice(message, argv = process.argv, env = process.env, runtime = getDefaultRuntime()) {
+  if (shouldSuppressCompatibilityNotice(argv, env, runtime)) {
+    return;
+  }
+  runtime.writeStderr?.(`Deprecated: ${message}
+`);
+}
+var DEPRECATION_MESSAGES = {
+  auto: `'build auto' remains available but is replaced by 'build "<task>"' (--quick forces the quick route, --max-turns 1 replaces --one-shot, --dry-run previews).`,
+  doAdhoc: `'build do "<task>"' remains available but is replaced by 'build "<task>"'.`,
+  doExisting: "'build do <id>' remains available but is replaced by 'build plan backlog execute <id>' (or 'build run task --backlog-item <id>' for an ad-hoc run).",
+  competitionQuick: `'--quick' remains available but is replaced by '--judge off' for skipping the AI judge; 'build "<task>"' owns the quick route.`
+};
+function attachCompatibilityNotice(command, legacyRoot) {
+  command.hook("preAction", () => {
+    maybeEmitCompatibilityNotice(legacyRoot);
+  });
+  return command;
+}
+
+export {
+  shouldSuppressCompatibilityNotice,
+  maybeEmitCompatibilityNotice,
+  maybeEmitDeprecationNotice,
+  DEPRECATION_MESSAGES,
+  attachCompatibilityNotice
+};
+//# sourceMappingURL=chunk-O5RRIUEP.js.map

package/dist/chunk-O5X6BKAO.js

@@ -0,0 +1,10 @@
+// src/utils/yes-no-answer.ts
+function isYesAnswer(answer) {
+  const normalized = answer.trim().toLowerCase();
+  return normalized === "y" || normalized === "yes";
+}
+
+export {
+  isYesAnswer
+};
+//# sourceMappingURL=chunk-O5X6BKAO.js.map

package/dist/chunk-O6ZQUVTR.js

@@ -0,0 +1,31 @@
+import {
+  PI_BACKEND_ENV_KEYS
+} from "./chunk-ONHAMBN6.js";
+
+// src/core/providers/pi/auth.ts
+function hasBackendEnvKey(env = process.env) {
+  return PI_BACKEND_ENV_KEYS.some((key) => Boolean(env?.[key]?.trim()));
+}
+async function probePiAuthState(env) {
+  if (hasBackendEnvKey(env)) return "yes";
+  return "unknown";
+}
+async function isAuthenticatedTriState(options = {}) {
+  const env = options?.env;
+  return probePiAuthState(env);
+}
+async function isAuthenticated(options = {}) {
+  const env = options?.env;
+  return await probePiAuthState(env) !== "no";
+}
+var auth = {
+  isAuthenticated,
+  isAuthenticatedTriState
+};
+
+export {
+  isAuthenticatedTriState,
+  isAuthenticated,
+  auth
+};
+//# sourceMappingURL=chunk-O6ZQUVTR.js.map