@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/setup-bb-plugin-FQXLA76Y.js

@@ -0,0 +1,531 @@
+import {
+  quotePosixShellArg
+} from "./chunk-N5DX4JAK.js";
+import {
+  findBuildPackageRoot
+} from "./chunk-RJ6RSNT6.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/cli/commands/setup-bb-plugin.ts
+import { randomUUID } from "crypto";
+import { access, open, readFile, unlink } from "fs/promises";
+import path from "path";
+import { execa } from "execa";
+import * as semver from "semver";
+var BB_PLUGIN_PACKAGE_NAME = "@ebrindley/bb-plugin-build";
+var BB_PLUGIN_RELATIVE_PATH = path.join("integrations", "bb-plugin-build");
+var BB_PLUGIN_ID = "build";
+var BB_FALLBACK_COMPATIBLE_RANGE = ">=0.0.0";
+function buildBbProjectRegistrationGuidance(cwd, initialized) {
+  if (!initialized) {
+    return [
+      "Next: initialize your target repository with `build init`, then add that repository as a BB project."
+    ];
+  }
+  const repositoryPath = path.resolve(cwd);
+  const projectName = path.basename(repositoryPath);
+  return [
+    `Next: open the Build panel for a BB project rooted at ${repositoryPath}.`,
+    `If needed: bb project create --name ${quotePosixShellArg(projectName)} --root ${quotePosixShellArg(repositoryPath)}`
+  ];
+}
+var BB_PLUGIN_TRUST_DISCLOSURE = "BB plugins are full-trust code inside the BB server and can access local BB data, including other plugins' secrets. The Build plugin starts the installed build executable as your host user in a selected local repository, reuses native provider CLI authentication, and may create worktrees or artifacts. This plugin does not read, copy, or broker provider credentials, and milestone-one Fusion actions do not push Git changes or synchronize managed planning files. Tracked backlog execution has separate runtime consent and may synchronize planning state, create commits, push branches, and open pull requests.";
+var BB_COMMAND_TIMEOUT_MS = 12e4;
+var BB_VERSION_TIMEOUT_MS = 15e3;
+var defaultRun = async (command, args, options = {}) => {
+  const result = await execa(command, [...args], {
+    cwd: options.cwd,
+    timeout: options.timeoutMs ?? BB_COMMAND_TIMEOUT_MS,
+    reject: false,
+    env: process.env
+  });
+  return {
+    stdout: result.stdout ?? "",
+    // A spawn failure carries its diagnostic on `shortMessage`, not stderr.
+    stderr: result.stderr || (result.failed ? result.shortMessage : "") || "",
+    // Execa reports no numeric exit code when the executable could not be
+    // spawned at all (ENOENT) or was killed by a signal. Coercing that to 0
+    // would report a successful `bb` invocation that simply printed nothing,
+    // so an unknown exit is normalized fail-closed to a failure.
+    exitCode: typeof result.exitCode === "number" ? result.exitCode : 1
+  };
+};
+async function defaultPathExists(targetPath) {
+  try {
+    await access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function defaultProbeWritable(targetPath) {
+  const probePath = path.join(targetPath, `.build-write-probe-${process.pid}-${randomUUID()}`);
+  const handle = await open(probePath, "wx");
+  try {
+    await handle.close();
+  } finally {
+    await unlink(probePath).catch(() => void 0);
+  }
+}
+function errorText(error) {
+  if (error && typeof error === "object") {
+    const stderr = "stderr" in error ? error.stderr : void 0;
+    if (typeof stderr === "string" && stderr.trim()) return stderr.trim();
+    const message = "message" in error ? error.message : void 0;
+    if (typeof message === "string" && message.trim()) return message.trim();
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+function parseBbVersion(output) {
+  const match = output.match(/\bv?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\b/);
+  return match?.[1] ?? null;
+}
+function isExpectedBbCliHelp(output) {
+  return ["list", "install", "remove", "enable"].every(
+    (command) => new RegExp(`^\\s*${command}\\b`, "m").test(output)
+  );
+}
+function resolveBbCompatibleRange(manifest) {
+  const declared = manifest?.engines?.bb;
+  if (typeof declared === "string" && semver.validRange(declared)) return declared;
+  return BB_FALLBACK_COMPATIBLE_RANGE;
+}
+function isBbVersionCompatible(version, range = BB_FALLBACK_COMPATIBLE_RANGE) {
+  const parsed = semver.valid(version.trim());
+  if (!parsed) return false;
+  if (!semver.validRange(range)) return false;
+  return semver.satisfies(parsed, range, { includePrerelease: true });
+}
+function optionalPluginPathField(record, key) {
+  const value = record[key];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function pluginRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const record = value;
+  const id = typeof record.id === "string" ? record.id : null;
+  const name = typeof record.name === "string" ? record.name : null;
+  const packageName = typeof record.package === "string" ? record.package : null;
+  if (id !== BB_PLUGIN_ID && name !== "Build" && packageName !== BB_PLUGIN_PACKAGE_NAME) {
+    return null;
+  }
+  return {
+    id: id ?? BB_PLUGIN_ID,
+    name,
+    version: typeof record.version === "string" ? record.version : null,
+    status: typeof record.status === "string" ? record.status : null,
+    enabled: typeof record.enabled === "boolean" ? record.enabled : null,
+    source: optionalPluginPathField(record, "source"),
+    rootDir: optionalPluginPathField(record, "rootDir") ?? optionalPluginPathField(record, "root") ?? optionalPluginPathField(record, "path")
+  };
+}
+function parseInstalledPlugin(output) {
+  const trimmed = output.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      const envelope = parsed;
+      const mutationPlugin = pluginRecord(envelope.plugin);
+      if (mutationPlugin) return mutationPlugin;
+      if (Array.isArray(envelope.plugins)) {
+        for (const entry of envelope.plugins) {
+          const plugin = pluginRecord(entry);
+          if (plugin) return plugin;
+        }
+      }
+    } else if (Array.isArray(parsed)) {
+      for (const entry of parsed) {
+        const plugin = pluginRecord(entry);
+        if (plugin) return plugin;
+      }
+    }
+  } catch {
+  }
+  for (const line of trimmed.split(/\r?\n/)) {
+    if (!line.includes(BB_PLUGIN_PACKAGE_NAME) && !/\bbuild(?:@|\b)/i.test(line)) continue;
+    const versionMatch = line.match(/\bv?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\b/);
+    const statusMatch = line.match(
+      /\b(running|disabled|error|incompatible|degraded|needs-configuration)\b/i
+    );
+    return {
+      id: BB_PLUGIN_ID,
+      name: "Build",
+      version: versionMatch?.[1] ?? null,
+      status: statusMatch?.[1]?.toLowerCase() ?? null,
+      enabled: statusMatch?.[1]?.toLowerCase() === "disabled" ? false : null,
+      source: null,
+      rootDir: null
+    };
+  }
+  return null;
+}
+function registeredPluginPath(plugin) {
+  if (plugin.rootDir) return plugin.rootDir;
+  if (plugin.source?.startsWith("path:")) return plugin.source.slice("path:".length);
+  return null;
+}
+function registrationMatchesPluginPath(plugin, pluginPath) {
+  const registeredPath = registeredPluginPath(plugin);
+  return registeredPath === null || path.resolve(registeredPath) === path.resolve(pluginPath);
+}
+function parseInstalledPluginVersion(output) {
+  return parseInstalledPlugin(output)?.version ?? null;
+}
+async function resolvePluginPath(deps) {
+  if (deps.pluginPath) {
+    return await deps.pathExists(deps.pluginPath) ? deps.pluginPath : null;
+  }
+  const root = deps.packageRoot === void 0 ? findBuildPackageRoot() : deps.packageRoot;
+  if (!root) return null;
+  const candidate = path.join(root, BB_PLUGIN_RELATIVE_PATH);
+  return await deps.pathExists(candidate) ? candidate : null;
+}
+async function readPluginManifest(pluginPath, readText) {
+  try {
+    const raw = await readText(path.join(pluginPath, "package.json"));
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function recoveryForMissingBb(range = BB_FALLBACK_COMPATIBLE_RANGE) {
+  return `Install a BB CLI matching ${range}, then rerun \`build provider setup --bb\`. Standalone Build remains fully usable without BB.`;
+}
+function recoveryForUnexpectedBb() {
+  return "Check which `bb` executable your PATH resolves and install the BB CLI whose `bb plugin` command supports list, install, remove, and enable. Then rerun `build provider setup --bb`. Standalone Build remains fully usable without BB.";
+}
+function recoveryForIncompatible(version, range) {
+  const seen = version ? ` (found ${version})` : "";
+  return `Install BB ${range}${seen}, then rerun \`build provider setup --bb\`. Standalone Build was not modified.`;
+}
+function recoveryForInstallFailure(pluginPath) {
+  const pathHint = pluginPath ? ` Or install manually: bb plugin install ${pluginPath} --yes` : "";
+  return `Build and provider configuration were not changed. Start the BB server and fix the reported plugin error, then rerun \`build provider setup --bb\`.${pathHint} If BB kept a partial registration, remove it with \`bb plugin remove ${BB_PLUGIN_ID}\`.`;
+}
+function isUsablePlugin(plugin) {
+  return plugin.enabled !== false && (plugin.status === "running" || plugin.status === "needs-configuration");
+}
+function isPluginListJson(output) {
+  try {
+    const parsed = JSON.parse(output);
+    return Array.isArray(parsed) || parsed !== null && typeof parsed === "object" && Array.isArray(parsed.plugins);
+  } catch {
+    return false;
+  }
+}
+async function readInstalledPlugin(run) {
+  try {
+    const jsonList = await run("bb", ["plugin", "list", "--json"], {
+      timeoutMs: BB_VERSION_TIMEOUT_MS
+    });
+    if ((jsonList.exitCode ?? 0) === 0 && isPluginListJson(jsonList.stdout)) {
+      return { available: true, plugin: parseInstalledPlugin(jsonList.stdout) };
+    }
+    const plainList = await run("bb", ["plugin", "list"], {
+      timeoutMs: BB_VERSION_TIMEOUT_MS
+    });
+    if ((plainList.exitCode ?? 0) === 0) {
+      return {
+        available: true,
+        plugin: parseInstalledPlugin(`${plainList.stdout}
+${plainList.stderr}`)
+      };
+    }
+  } catch {
+  }
+  return { available: false, plugin: null };
+}
+async function setupBbPlugin(dependencies = {}) {
+  const run = dependencies.run ?? defaultRun;
+  const pathExists = dependencies.pathExists ?? defaultPathExists;
+  const probeWritable = dependencies.probeWritable ?? defaultProbeWritable;
+  const readText = dependencies.readText ?? ((targetPath) => readFile(targetPath, "utf8"));
+  const force = dependencies.force === true;
+  const pluginPath = await resolvePluginPath({
+    packageRoot: dependencies.packageRoot,
+    pluginPath: dependencies.pluginPath,
+    pathExists
+  });
+  const base = {
+    pluginPath,
+    pluginPackage: BB_PLUGIN_PACKAGE_NAME,
+    pluginVersion: null,
+    bbPluginSdkRange: null
+  };
+  if (!pluginPath) {
+    return {
+      ...base,
+      ok: false,
+      status: "plugin_missing",
+      bbVersion: null,
+      installedVersion: null,
+      message: "The bundled Build BB plugin package was not found next to this Build install. Standalone Build remains usable.",
+      recovery: "Use a Build install that ships integrations/bb-plugin-build, or install the plugin from a clone with `bb plugin install <path-to-integrations/bb-plugin-build>`."
+    };
+  }
+  const manifest = await readPluginManifest(pluginPath, readText);
+  const targetVersion = typeof manifest?.version === "string" ? manifest.version : null;
+  const bbPluginSdkRange = typeof manifest?.engines?.bbPluginSdk === "string" ? manifest.engines.bbPluginSdk : null;
+  if (!manifest || manifest.name !== BB_PLUGIN_PACKAGE_NAME || !targetVersion || !bbPluginSdkRange || !semver.validRange(bbPluginSdkRange)) {
+    return {
+      ...base,
+      ok: false,
+      status: "plugin_missing",
+      bbVersion: null,
+      installedVersion: null,
+      message: `Plugin package at ${pluginPath} is missing or is not ${BB_PLUGIN_PACKAGE_NAME}.`,
+      recovery: recoveryForInstallFailure(pluginPath)
+    };
+  }
+  const resolvedBase = {
+    ...base,
+    pluginVersion: targetVersion,
+    bbPluginSdkRange
+  };
+  const compatibleRange = resolveBbCompatibleRange(manifest);
+  let bbVersion = null;
+  try {
+    const helpResult = await run("bb", ["plugin", "--help"], { timeoutMs: BB_VERSION_TIMEOUT_MS });
+    if (helpResult.exitCode !== 0 || !isExpectedBbCliHelp(`${helpResult.stdout}
+${helpResult.stderr}`)) {
+      return {
+        ...resolvedBase,
+        ok: false,
+        status: "bb_incompatible",
+        bbVersion: null,
+        installedVersion: null,
+        message: "The `bb` executable on PATH is not a supported BB CLI.",
+        recovery: recoveryForUnexpectedBb()
+      };
+    }
+    const versionResult = await run("bb", ["--version"], { timeoutMs: BB_VERSION_TIMEOUT_MS });
+    if (versionResult.exitCode !== 0) {
+      return {
+        ...resolvedBase,
+        ok: false,
+        status: "bb_missing",
+        bbVersion: null,
+        installedVersion: null,
+        message: `BB is unavailable: ${(versionResult.stderr || versionResult.stdout || "non-zero exit").trim()}`,
+        recovery: recoveryForMissingBb(compatibleRange)
+      };
+    }
+    bbVersion = parseBbVersion(`${versionResult.stdout}
+${versionResult.stderr}`);
+  } catch (error) {
+    return {
+      ...resolvedBase,
+      ok: false,
+      status: "bb_missing",
+      bbVersion: null,
+      installedVersion: null,
+      message: `BB is unavailable: ${errorText(error)}`,
+      recovery: recoveryForMissingBb(compatibleRange)
+    };
+  }
+  if (!bbVersion) {
+    return {
+      ...resolvedBase,
+      ok: false,
+      status: "bb_incompatible",
+      bbVersion: null,
+      installedVersion: null,
+      message: "BB is installed, but its version could not be verified from `bb --version`.",
+      recovery: recoveryForIncompatible(null, compatibleRange)
+    };
+  }
+  if (!isBbVersionCompatible(bbVersion, compatibleRange)) {
+    return {
+      ...resolvedBase,
+      ok: false,
+      status: "bb_incompatible",
+      bbVersion,
+      installedVersion: null,
+      message: `BB ${bbVersion} is incompatible with the Build plugin (requires ${compatibleRange}).`,
+      recovery: recoveryForIncompatible(bbVersion, compatibleRange)
+    };
+  }
+  try {
+    await probeWritable(pluginPath);
+  } catch (error) {
+    return {
+      ...resolvedBase,
+      ok: false,
+      status: "plugin_not_writable",
+      bbVersion,
+      installedVersion: null,
+      message: `The Build BB plugin directory is not writable: ${pluginPath}.`,
+      recovery: `BB must be able to build and refresh the plugin frontend in that directory. Fix its permissions, then rerun \`build provider setup --bb\`. Details: ${errorText(error)}`
+    };
+  }
+  const inventory = await readInstalledPlugin(run);
+  let installed = inventory.plugin;
+  const installedVersion = installed?.version ?? null;
+  const installedPath = installed ? registeredPluginPath(installed) : null;
+  const installedFromCurrentPath = installed === null || registrationMatchesPluginPath(installed, pluginPath);
+  await dependencies.onBeforeEnable?.({
+    bbVersion,
+    bbCompatibleRange: compatibleRange,
+    bbPluginSdkRange,
+    pluginId: BB_PLUGIN_ID,
+    pluginPath,
+    pluginVersion: targetVersion,
+    existingVersion: installedVersion,
+    reinstall: force
+  });
+  if (!force && installedVersion === targetVersion && installed !== null && installedFromCurrentPath && isUsablePlugin(installed)) {
+    return {
+      ...resolvedBase,
+      ok: true,
+      status: "already_current",
+      bbVersion,
+      installedVersion,
+      message: `Build BB plugin ${installedVersion} is already installed for BB ${bbVersion}.`,
+      recovery: null
+    };
+  }
+  if (!force && installed !== null && !(installedVersion === targetVersion && installed.enabled === false && installedFromCurrentPath)) {
+    const pathMismatch = installedPath !== null && !installedFromCurrentPath;
+    return {
+      ...resolvedBase,
+      ok: false,
+      status: "upgrade_required",
+      bbVersion,
+      installedVersion,
+      message: pathMismatch ? `BB has Build plugin ${installedVersion ?? "with an unknown version"} registered from ${installedPath}, but this Build installation provides it from ${pluginPath}. Automatic setup will not replace an existing local-path registration.` : `BB has Build plugin ${installedVersion ?? "with an unknown version"} registered. Automatic setup will not replace an existing local-path registration.`,
+      recovery: "Review the version and trust disclosure, then explicitly replace it with `build provider setup --bb --reinstall`. Standalone Build remains usable."
+    };
+  }
+  const hadPriorInstall = installed !== null;
+  const movingRegistration = force && installed !== null && !installedFromCurrentPath;
+  try {
+    if (!force && installedVersion === targetVersion && installed?.enabled === false) {
+      const enableResult = await run("bb", ["plugin", "enable", BB_PLUGIN_ID, "--json"], {
+        timeoutMs: BB_COMMAND_TIMEOUT_MS
+      });
+      if ((enableResult.exitCode ?? 0) !== 0) {
+        throw new Error(
+          (enableResult.stderr || enableResult.stdout || `bb plugin enable exited ${enableResult.exitCode}`).trim()
+        );
+      }
+      installed = parseInstalledPlugin(enableResult.stdout) ?? (await readInstalledPlugin(run)).plugin;
+      if (!installed || installed.version !== targetVersion || !isUsablePlugin(installed)) {
+        throw new Error(
+          `BB reported plugin ${installed?.version ?? "with unknown version"} in status ${installed?.status ?? "unknown"} after enablement; expected ${targetVersion}`
+        );
+      }
+      return {
+        ...resolvedBase,
+        ok: true,
+        status: "enabled",
+        bbVersion,
+        installedVersion: installed.version,
+        message: `Enabled Build BB plugin ${installed.version ?? targetVersion} for BB ${bbVersion}.`,
+        recovery: null
+      };
+    }
+    const installResult = await run("bb", ["plugin", "install", pluginPath, "--yes", "--json"], {
+      timeoutMs: BB_COMMAND_TIMEOUT_MS
+    });
+    if ((installResult.exitCode ?? 0) !== 0) {
+      throw new Error(
+        (installResult.stderr || installResult.stdout || `bb plugin install exited ${installResult.exitCode}`).trim()
+      );
+    }
+    installed = parseInstalledPlugin(installResult.stdout) ?? (await readInstalledPlugin(run)).plugin;
+    if (movingRegistration) {
+      installed = (await readInstalledPlugin(run)).plugin ?? installed;
+    }
+    if (installed?.enabled === false) {
+      const enableResult = await run("bb", ["plugin", "enable", BB_PLUGIN_ID, "--json"], {
+        timeoutMs: BB_COMMAND_TIMEOUT_MS
+      });
+      if ((enableResult.exitCode ?? 0) !== 0) {
+        throw new Error(
+          (enableResult.stderr || enableResult.stdout || `bb plugin enable exited ${enableResult.exitCode}`).trim()
+        );
+      }
+      installed = parseInstalledPlugin(enableResult.stdout) ?? (await readInstalledPlugin(run)).plugin;
+      if (movingRegistration) {
+        installed = (await readInstalledPlugin(run)).plugin ?? installed;
+      }
+    }
+    const movedPath = installed ? registeredPluginPath(installed) : null;
+    if (!installed || installed.version !== targetVersion || !isUsablePlugin(installed) || movingRegistration && (movedPath === null || path.resolve(movedPath) !== path.resolve(pluginPath))) {
+      throw new Error(
+        `BB registered plugin ${installed?.version ?? "with unknown version"} in status ${installed?.status ?? "unknown"}; expected ${targetVersion} with plugin SDK range ${bbPluginSdkRange}` + (movingRegistration ? ` from ${pluginPath}` : "")
+      );
+    }
+    return {
+      ...resolvedBase,
+      ok: true,
+      status: hadPriorInstall ? "upgraded" : "installed",
+      bbVersion,
+      installedVersion: installed.version,
+      message: hadPriorInstall ? `Upgraded Build BB plugin to ${installed.version ?? targetVersion} for BB ${bbVersion}.` : `Installed Build BB plugin ${installed.version ?? targetVersion} for BB ${bbVersion}.`,
+      recovery: null
+    };
+  } catch (error) {
+    const failureMessage = errorText(error);
+    let rolledBack = false;
+    if (hadPriorInstall) {
+      const postFailureInventory = await readInstalledPlugin(run);
+      const observedPlugin = postFailureInventory.available ? postFailureInventory.plugin : null;
+      const observedVersion = observedPlugin?.version ?? null;
+      const observedStatus = observedPlugin?.status ?? null;
+      return {
+        ...resolvedBase,
+        ok: false,
+        status: "install_failed",
+        bbVersion,
+        installedVersion: observedVersion,
+        message: `BB could not activate the explicitly requested Build plugin replacement: ${failureMessage}. Build did not remove the previous registration; BB now reports ${observedVersion ?? "an unknown installed version"} in status ${observedStatus ?? "unknown"}.`,
+        recovery: "Standalone Build remains usable. Fix the BB/plugin error and rerun `build provider setup --bb --reinstall`, or disable/remove the Build plugin in BB."
+      };
+    }
+    try {
+      if (!inventory.available) throw new Error("BB plugin inventory was unavailable");
+      const uninstall = await run("bb", ["plugin", "remove", BB_PLUGIN_ID, "--json"], {
+        timeoutMs: BB_COMMAND_TIMEOUT_MS
+      });
+      rolledBack = (uninstall.exitCode ?? 0) === 0;
+    } catch {
+      rolledBack = false;
+    }
+    return {
+      ...resolvedBase,
+      ok: false,
+      status: rolledBack ? "rolled_back" : "install_failed",
+      bbVersion,
+      installedVersion: null,
+      message: rolledBack ? `BB plugin install failed and was rolled back: ${failureMessage}` : `BB plugin install failed: ${failureMessage}`,
+      recovery: recoveryForInstallFailure(pluginPath)
+    };
+  }
+}
+var _testing = {
+  parseBbVersion,
+  isBbVersionCompatible,
+  isExpectedBbCliHelp,
+  resolveBbCompatibleRange,
+  parseInstalledPluginVersion,
+  resolvePluginPath
+};
+export {
+  BB_FALLBACK_COMPATIBLE_RANGE,
+  BB_PLUGIN_ID,
+  BB_PLUGIN_PACKAGE_NAME,
+  BB_PLUGIN_RELATIVE_PATH,
+  BB_PLUGIN_TRUST_DISCLOSURE,
+  _testing,
+  buildBbProjectRegistrationGuidance,
+  isBbVersionCompatible,
+  isExpectedBbCliHelp,
+  parseBbVersion,
+  parseInstalledPlugin,
+  parseInstalledPluginVersion,
+  resolveBbCompatibleRange,
+  setupBbPlugin
+};
+//# sourceMappingURL=setup-bb-plugin-FQXLA76Y.js.map