@poetic-ai/poetic 1.42.0

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

@@ -0,0 +1,738 @@
+import {
+  quotePosixShellArg
+} from "./chunk-N5DX4JAK.js";
+import {
+  findPoeticPackageRoot
+} from "./chunk-GSGD5E4C.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/cli/commands/setup-bb-plugin.ts
+import { access, readFile as readFile2 } from "fs/promises";
+import path2 from "path";
+import { execa } from "execa";
+import * as semver from "semver";
+
+// src/cli/commands/bb-sdk-provenance.ts
+import { createHash } from "crypto";
+import { readFile } from "fs/promises";
+import path from "path";
+var SDK_PROVENANCE_RELATIVE_PATH = path.join("types", "PROVENANCE.json");
+var DIGEST_ALGORITHM = "sha256";
+var KNOWN_GENERATION_METHODS = /* @__PURE__ */ new Set([
+  "vendored-rollup-dts-bundle",
+  "vendored-verbatim",
+  "generated-from-bb-checkout"
+]);
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function parseDeclarationRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const record = value;
+  if (!isNonEmptyString(record.file) || !isNonEmptyString(record.specifier) || !isNonEmptyString(record.sha256) || typeof record.byteLength !== "number" || !Number.isInteger(record.byteLength) || record.byteLength <= 0 || !isStringArray(record.requiredExports) || record.requiredExports.length === 0) {
+    return null;
+  }
+  return {
+    file: record.file,
+    specifier: record.specifier,
+    sha256: record.sha256,
+    byteLength: record.byteLength,
+    requiredExports: [...record.requiredExports]
+  };
+}
+function parseSdkProvenance(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const record = parsed;
+  const upstream = record.upstream;
+  const generation = record.generation;
+  const testingHarness = record.testingHarness;
+  if (!isNonEmptyString(record.schemaVersion) || !upstream || typeof upstream !== "object" || Array.isArray(upstream) || !generation || typeof generation !== "object" || Array.isArray(generation) || !testingHarness || typeof testingHarness !== "object" || Array.isArray(testingHarness) || !Array.isArray(record.declarations)) {
+    return null;
+  }
+  const upstreamRecord = upstream;
+  const generationRecord = generation;
+  const harnessRecord = testingHarness;
+  const sourceCommit = upstreamRecord.sourceCommit;
+  const sourceCommitStatus = upstreamRecord.sourceCommitStatus;
+  if (!isNonEmptyString(upstreamRecord.repository) || !isNonEmptyString(sourceCommit) || sourceCommitStatus !== "recorded" || !isNonEmptyString(upstreamRecord.sdkVersion) || !isNonEmptyString(upstreamRecord.sdkVersionRange) || !isNonEmptyString(generationRecord.method) || !isNonEmptyString(generationRecord.command) || !isNonEmptyString(generationRecord.notes) || !isNonEmptyString(harnessRecord.specifier) || typeof harnessRecord.vendored !== "boolean" || !isStringArray(harnessRecord.requiredExports) || !isNonEmptyString(harnessRecord.notes)) {
+    return null;
+  }
+  if (!KNOWN_GENERATION_METHODS.has(generationRecord.method)) return null;
+  const declarations = [];
+  for (const entry of record.declarations) {
+    const declaration = parseDeclarationRecord(entry);
+    if (!declaration) return null;
+    declarations.push(declaration);
+  }
+  if (declarations.length === 0) return null;
+  const vendoredInPoeticCommit = record.vendoredInPoeticCommit;
+  if (!(vendoredInPoeticCommit === null || isNonEmptyString(vendoredInPoeticCommit))) return null;
+  return {
+    schemaVersion: record.schemaVersion,
+    upstream: {
+      repository: upstreamRecord.repository,
+      sourceCommit,
+      sourceCommitStatus,
+      sdkVersion: upstreamRecord.sdkVersion,
+      sdkVersionRange: upstreamRecord.sdkVersionRange
+    },
+    generation: {
+      method: generationRecord.method,
+      command: generationRecord.command,
+      notes: generationRecord.notes
+    },
+    vendoredInPoeticCommit: vendoredInPoeticCommit === null ? null : vendoredInPoeticCommit,
+    declarations,
+    testingHarness: {
+      specifier: harnessRecord.specifier,
+      vendored: harnessRecord.vendored,
+      requiredExports: [...harnessRecord.requiredExports],
+      notes: harnessRecord.notes
+    }
+  };
+}
+function digestDeclaration(text) {
+  return createHash(DIGEST_ALGORITHM).update(text, "utf8").digest("hex");
+}
+function declaredExports(text) {
+  const found = /* @__PURE__ */ new Set();
+  const pattern = /^export(?:\s+type)?\s*\{([^}]*)\}\s*;?\s*$/gm;
+  let match = pattern.exec(text);
+  while (match !== null) {
+    for (const clause of (match[1] ?? "").split(",")) {
+      const published = clause.includes(" as ") ? clause.slice(clause.lastIndexOf(" as ") + 4) : clause;
+      const name = published.trim();
+      if (name) found.add(name);
+    }
+    match = pattern.exec(text);
+  }
+  return found;
+}
+function recoveryFor(provenance) {
+  if (!provenance) {
+    return `Restore ${SDK_PROVENANCE_RELATIVE_PATH} in the Poetic BB plugin package. Standalone Poetic is unaffected; only \`poetic provider setup --bb\` and the BB panel need it.`;
+  }
+  return `Re-vendor the declarations from ${provenance.upstream.sourceCommit} using \`${provenance.generation.command}\`, then update sha256, byteLength, and upstream.sourceCommit in ${SDK_PROVENANCE_RELATIVE_PATH}. Standalone Poetic is unaffected; only the optional BB path is.`;
+}
+async function checkSdkCompatibility(options) {
+  const pluginPath = options.pluginPath;
+  const readText = options.readText ?? ((absolutePath) => readFile(absolutePath, "utf8"));
+  const findings = [];
+  let raw;
+  try {
+    raw = await readText(path.join(pluginPath, SDK_PROVENANCE_RELATIVE_PATH));
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    findings.push({
+      kind: "provenance_unreadable",
+      file: SDK_PROVENANCE_RELATIVE_PATH,
+      message: `BB plugin SDK provenance record could not be read: ${detail}`
+    });
+    return {
+      ok: false,
+      provenance: null,
+      findings,
+      error: findings[0]?.message ?? "BB plugin SDK provenance record could not be read.",
+      recovery: recoveryFor(null)
+    };
+  }
+  const provenance = parseSdkProvenance(raw);
+  if (!provenance) {
+    findings.push({
+      kind: "provenance_invalid",
+      file: SDK_PROVENANCE_RELATIVE_PATH,
+      message: `BB plugin SDK provenance record at ${SDK_PROVENANCE_RELATIVE_PATH} is not a valid provenance document (upstream commit/version, generation method, and per-declaration digests are all required).`
+    });
+    return {
+      ok: false,
+      provenance: null,
+      findings,
+      error: findings[0]?.message ?? "BB plugin SDK provenance record is invalid.",
+      recovery: recoveryFor(null)
+    };
+  }
+  if (typeof options.declaredSdkRange === "string" && options.declaredSdkRange !== provenance.upstream.sdkVersionRange) {
+    findings.push({
+      kind: "sdk_version_mismatch",
+      file: null,
+      message: `Plugin manifest requires BB plugin SDK ${options.declaredSdkRange}, but the vendored declarations were recorded against ${provenance.upstream.sdkVersionRange} (SDK ${provenance.upstream.sdkVersion}).`
+    });
+  }
+  for (const declaration of provenance.declarations) {
+    let text;
+    try {
+      text = await readText(path.join(pluginPath, declaration.file));
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      findings.push({
+        kind: "declaration_unreadable",
+        file: declaration.file,
+        message: `Vendored declaration ${declaration.file} could not be read: ${detail}`
+      });
+      continue;
+    }
+    const byteLength = Buffer.byteLength(text, "utf8");
+    if (byteLength !== declaration.byteLength) {
+      findings.push({
+        kind: "byte_length",
+        file: declaration.file,
+        message: `Vendored declaration ${declaration.file} is ${byteLength} bytes but provenance records ${declaration.byteLength}.`
+      });
+    }
+    const digest = digestDeclaration(text);
+    if (digest !== declaration.sha256) {
+      findings.push({
+        kind: "digest",
+        file: declaration.file,
+        message: `Vendored declaration ${declaration.file} for ${declaration.specifier} drifted from its recorded provenance (${DIGEST_ALGORITHM} ${digest} != ${declaration.sha256}) while the recorded SDK version stayed ${provenance.upstream.sdkVersion}. Semver cannot detect this change.`
+      });
+    }
+    const exported = declaredExports(text);
+    const missing = declaration.requiredExports.filter((name) => !exported.has(name));
+    if (missing.length > 0) {
+      findings.push({
+        kind: "missing_export",
+        file: declaration.file,
+        message: `Vendored declaration ${declaration.file} no longer exports ${missing.join(", ")}, which ${declaration.specifier} consumers in this plugin require.`
+      });
+    }
+  }
+  if (findings.length === 0) {
+    return { ok: true, provenance, findings, error: "", recovery: null };
+  }
+  return {
+    ok: false,
+    provenance,
+    findings,
+    error: `BB plugin SDK compatibility check failed:
+- ${findings.map((finding) => finding.message).join("\n- ")}`,
+    recovery: recoveryFor(provenance)
+  };
+}
+
+// src/cli/commands/setup-bb-plugin.ts
+var BB_PLUGIN_PACKAGE_NAME = "@poetic-ai/bb-plugin-poetic";
+var BB_PLUGIN_RELATIVE_PATH = path2.join("integrations", "bb-plugin-poetic");
+var BB_PLUGIN_ID = "poetic";
+var BB_FALLBACK_COMPATIBLE_RANGE = ">=0.0.0";
+function buildBbProjectRegistrationGuidance(cwd, initialized) {
+  if (!initialized) {
+    return [
+      "Next: initialize your target repository with `poetic init`, then add that repository as a BB project."
+    ];
+  }
+  const repositoryPath = path2.resolve(cwd);
+  const projectName = path2.basename(repositoryPath);
+  return [
+    `Next: open the Poetic 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 Poetic plugin starts the installed poetic 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;
+  }
+}
+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 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 !== "Poetic" && 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) && !/\bpoetic(?:@|\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: "Poetic",
+      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 || path2.resolve(registeredPath) === path2.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 ? findPoeticPackageRoot() : deps.packageRoot;
+  if (!root) return null;
+  const candidate = path2.join(root, BB_PLUGIN_RELATIVE_PATH);
+  return await deps.pathExists(candidate) ? candidate : null;
+}
+async function readPluginManifest(pluginPath, readText) {
+  try {
+    const raw = await readText(path2.join(pluginPath, "package.json"));
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function summarizeSdkProvenance(report) {
+  return {
+    ok: report.ok,
+    sourceCommit: report.provenance?.upstream.sourceCommit ?? null,
+    sdkVersion: report.provenance?.upstream.sdkVersion ?? null,
+    generationMethod: report.provenance?.generation.method ?? null,
+    driftKinds: report.findings.map((finding) => finding.kind)
+  };
+}
+function recoveryForMissingBb(range = BB_FALLBACK_COMPATIBLE_RANGE) {
+  return `Install a BB CLI matching ${range}, then rerun \`poetic provider setup --bb\`. Standalone Poetic remains fully usable without BB.`;
+}
+function recoveryForIncompatible(version, range) {
+  const seen = version ? ` (found ${version})` : "";
+  return `Install BB ${range}${seen}, then rerun \`poetic provider setup --bb\`. Standalone Poetic was not modified.`;
+}
+function recoveryForInstallFailure(pluginPath) {
+  const pathHint = pluginPath ? ` Or install manually: bb plugin install ${pluginPath} --yes` : "";
+  return `Poetic and provider configuration were not changed. Fix the BB/plugin error, then rerun \`poetic 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 readText = dependencies.readText ?? ((targetPath) => readFile2(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,
+    sdkProvenance: null
+  };
+  if (!pluginPath) {
+    return {
+      ...base,
+      ok: false,
+      status: "plugin_missing",
+      bbVersion: null,
+      installedVersion: null,
+      message: "The bundled Poetic BB plugin package was not found next to this Poetic install. Standalone Poetic remains usable.",
+      recovery: "Use a Poetic install that ships integrations/bb-plugin-poetic, or install the plugin from a clone with `bb plugin install <path-to-integrations/bb-plugin-poetic>`."
+    };
+  }
+  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 sdkReport = await checkSdkCompatibility({
+    pluginPath,
+    readText,
+    declaredSdkRange: bbPluginSdkRange
+  });
+  const sdkProvenance = summarizeSdkProvenance(sdkReport);
+  const resolvedBase = {
+    ...base,
+    pluginVersion: targetVersion,
+    bbPluginSdkRange,
+    sdkProvenance
+  };
+  if (!sdkReport.ok) {
+    return {
+      ...resolvedBase,
+      ok: false,
+      status: "sdk_declarations_drifted",
+      bbVersion: null,
+      installedVersion: null,
+      message: sdkReport.error,
+      recovery: sdkReport.recovery
+    };
+  }
+  const compatibleRange = resolveBbCompatibleRange(manifest);
+  let bbVersion = null;
+  try {
+    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 Poetic plugin (requires ${compatibleRange}).`,
+      recovery: recoveryForIncompatible(bbVersion, compatibleRange)
+    };
+  }
+  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,
+    sdkProvenance
+  });
+  if (!force && installedVersion === targetVersion && installed !== null && installedFromCurrentPath && isUsablePlugin(installed)) {
+    return {
+      ...resolvedBase,
+      ok: true,
+      status: "already_current",
+      bbVersion,
+      installedVersion,
+      message: `Poetic 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 Poetic plugin ${installedVersion ?? "with an unknown version"} registered from ${installedPath}, but this Poetic installation provides it from ${pluginPath}. Automatic setup will not replace an existing local-path registration.` : `BB has Poetic 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 `poetic provider setup --bb --reinstall`. Standalone Poetic remains usable."
+    };
+  }
+  const hadPriorInstall = installed !== null;
+  let removedPriorRegistration = false;
+  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 Poetic BB plugin ${installed.version ?? targetVersion} for BB ${bbVersion}.`,
+        recovery: null
+      };
+    }
+    if (force && installed !== null) {
+      const priorPath = registeredPluginPath(installed);
+      const removeResult = await run("bb", ["plugin", "remove", BB_PLUGIN_ID, "--json"], {
+        timeoutMs: BB_COMMAND_TIMEOUT_MS
+      });
+      if ((removeResult.exitCode ?? 0) !== 0) {
+        const removeFailure = (removeResult.stderr || removeResult.stdout || `bb plugin remove exited ${removeResult.exitCode}`).trim();
+        const pathNote = priorPath ? ` (registered from ${priorPath})` : "";
+        return {
+          ...resolvedBase,
+          ok: false,
+          status: "install_failed",
+          bbVersion,
+          installedVersion,
+          message: `Could not remove the existing Poetic BB plugin registration before reinstall${pathNote}: ${removeFailure}. BB still reports ${installedVersion ?? "an unknown installed version"} in status ${installed.status ?? "unknown"}.`,
+          recovery: `Standalone Poetic remains usable. Fix the BB remove error, or remove the Poetic plugin with \`bb plugin remove ${BB_PLUGIN_ID}\`, then rerun \`poetic provider setup --bb --reinstall\`.`
+        };
+      }
+      removedPriorRegistration = true;
+      installed = 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 (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 registered plugin ${installed?.version ?? "with unknown version"} in status ${installed?.status ?? "unknown"}; expected ${targetVersion} with plugin SDK range ${bbPluginSdkRange}`
+      );
+    }
+    return {
+      ...resolvedBase,
+      ok: true,
+      status: hadPriorInstall || removedPriorRegistration ? "upgraded" : "installed",
+      bbVersion,
+      installedVersion: installed.version,
+      message: hadPriorInstall || removedPriorRegistration ? `Upgraded Poetic BB plugin to ${installed.version ?? targetVersion} for BB ${bbVersion}.` : `Installed Poetic 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;
+      const removalNote = removedPriorRegistration ? "The previous Poetic registration was removed before install failed; " : "";
+      return {
+        ...resolvedBase,
+        ok: false,
+        status: "install_failed",
+        bbVersion,
+        installedVersion: observedVersion,
+        message: `BB could not activate the explicitly requested Poetic plugin replacement: ${failureMessage}. ` + removalNote + `BB now reports ${observedVersion ?? "an unknown installed version"} in status ${observedStatus ?? "unknown"}; local-path replacements are not transactionally restorable by Poetic.`,
+        recovery: "Standalone Poetic remains usable. Fix the BB/plugin error and rerun `poetic provider setup --bb --reinstall`, or disable/remove the Poetic 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,
+  resolveBbCompatibleRange,
+  parseInstalledPluginVersion,
+  resolvePluginPath,
+  summarizeSdkProvenance
+};
+export {
+  BB_FALLBACK_COMPATIBLE_RANGE,
+  BB_PLUGIN_ID,
+  BB_PLUGIN_PACKAGE_NAME,
+  BB_PLUGIN_RELATIVE_PATH,
+  BB_PLUGIN_TRUST_DISCLOSURE,
+  _testing,
+  buildBbProjectRegistrationGuidance,
+  isBbVersionCompatible,
+  parseBbVersion,
+  parseInstalledPlugin,
+  parseInstalledPluginVersion,
+  resolveBbCompatibleRange,
+  setupBbPlugin
+};
+//# sourceMappingURL=setup-bb-plugin-QAQWZCV5.js.map