@unbrained/pm-cli 2026.7.6 → 2026.7.8

package/dist/cli-bundle/chunks/{chunk-W6DYWXPQ.js → chunk-P2WE5KCU.js}

@@ -1,10 +1,10 @@
 import {
-  normalizeParentReferencePolicy,
-  normalizeSprintReleaseFormatPolicy
-} from "./chunk-ALFPSEWO.js";
+  readManagedExtensionState,
+  runExtension
+} from "./chunk-FL625JJM.js";
 import {
   migrateItemFilesToFormat
-} from "./chunk-O6AWCQRQ.js";
+} from "./chunk-3UXIMY62.js";
 import {
   NESTED_SETTING_DESCRIPTORS,
   parseNestedSettingValue,
@@ -12,26 +12,32 @@ import {
   resolveNestedSettingDescriptor,
   writeNestedSettingValue
 } from "./chunk-VUHVWI4C.js";
+import {
+  normalizeParentReferencePolicy,
+  normalizeSprintReleaseFormatPolicy
+} from "./chunk-3YJDIJIE.js";
+import {
+  buildInvalidTypeError
+} from "./chunk-7UCBLJDF.js";
 import {
   PmCliError,
   getActiveExtensionRegistrations,
   readSettingsWithMetadata,
   writeSettings
-} from "./chunk-SHQY2IDC.js";
-import {
-  buildInvalidTypeError
-} from "./chunk-NGXQ3PFT.js";
+} from "./chunk-BPJ5NYSJ.js";
 import {
   CONTEXT_DEPTH_VALUES,
   EXIT_CODE,
   getSettingsPath,
   pathExists,
+  resolveExtensionRoots,
   resolveGlobalPmRoot,
   resolveItemTypeRegistry,
   resolveItemTypesFilePath,
+  resolvePmCliVersion,
   resolvePmRoot,
   resolveTypeName
-} from "./chunk-LK6XLOGP.js";
+} from "./chunk-2BVD4ZD2.js";
 
 // dist/core/config/positional-value.js
 !(function() {
@@ -1042,32 +1048,253 @@ async function runConfig(scopeValue, actionValue, keyValue, options, global2, va
   assertConfigKeyDefined(key);
   return action === "get" ? buildConfigGetResult(context, key) : setConfigValue(context, key, routedOptions);
 }
-var _testOnlyConfigCommand = {
-  hasGovernanceValidationMirrorChange,
-  applyPositionalValue,
-  normalizeAction,
-  normalizeCriteria,
-  normalizeGovernanceCloseValidationDefault,
-  normalizeGovernanceCreateModeDefault,
-  normalizeGovernanceForceRequiredForStaleLockPolicy,
-  normalizeGovernanceOwnershipEnforcement,
-  normalizeGovernancePreset,
-  normalizeGovernanceRequireCloseReasonPolicy,
-  normalizeGovernanceWorkflowEnforcement,
-  normalizeHistoryMissingStreamPolicy,
-  normalizeItemFormat,
-  normalizeKey,
-  normalizeMetadataRequiredFields,
-  normalizePolicyForConflict,
-  normalizeScope,
-  normalizeTelemetryTrackingPolicy,
-  normalizeTestResultTrackingPolicy,
-  normalizeValidateMetadataProfile,
-  normalizeWarnings
-};
+
+// dist/cli/commands/upgrade.js
+import { execFile } from "node:child_process";
+import path from "node:path";
+import { promisify } from "node:util";
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "23e180a8-5d22-5a29-9970-219fbdc3d967");
+  } catch (e2) {
+  }
+})();
+var execFileAsync = promisify(execFile);
+var DEFAULT_CLI_PACKAGE = "@unbrained/pm-cli";
+var DEFAULT_TAG = "latest";
+function resolveScope(options) {
+  const projectLike = options.project === true || options.local === true;
+  const global2 = options.global === true;
+  if (projectLike && global2) {
+    throw new PmCliError('Options "--project/--local" and "--global" are mutually exclusive.', EXIT_CODE.USAGE);
+  }
+  return global2 ? "global" : "project";
+}
+function normalizeTarget(value) {
+  return value.trim().toLowerCase();
+}
+function packageRecordMatchesTarget(record, target) {
+  const normalizedTarget = normalizeTarget(target);
+  const values = [
+    record.name,
+    record.directory,
+    record.source.input,
+    record.source.location,
+    record.source.package,
+    record.source.repository,
+    record.source.owner && record.source.repo ? `${record.source.owner}/${record.source.repo}` : void 0
+  ];
+  return values.some((value) => typeof value === "string" && normalizeTarget(value) === normalizedTarget);
+}
+function resolveRoots(scope, global2) {
+  const pmRoot = resolvePmRoot(process.cwd(), global2.path);
+  const roots = resolveExtensionRoots(pmRoot, process.cwd());
+  return {
+    selected_root: scope === "global" ? roots.global : roots.project
+  };
+}
+async function defaultCommandRunner(command, args, options) {
+  try {
+    const result = await execFileAsync(command, args, {
+      cwd: options?.cwd,
+      encoding: "utf8"
+    });
+    return {
+      stdout: result.stdout,
+      stderr: result.stderr
+    };
+  } catch (error) {
+    const stderr = typeof error === "object" && error !== null && "stderr" in error ? String(error.stderr ?? "") : "";
+    const message = stderr.trim().length > 0 ? stderr.trim() : error instanceof Error ? error.message : String(error);
+    throw new PmCliError(`Command failed: ${command} ${args.join(" ")}
+${message}`, EXIT_CODE.GENERIC_FAILURE);
+  }
+}
+async function readCurrentVersion() {
+  return resolvePmCliVersion(import.meta.url, ["../../.."]);
+}
+function resolveTag(options) {
+  return typeof options.tag === "string" && options.tag.trim().length > 0 ? options.tag.trim() : DEFAULT_TAG;
+}
+function resolveCliPackage(options) {
+  return typeof options.packageName === "string" && options.packageName.trim().length > 0 ? options.packageName.trim() : DEFAULT_CLI_PACKAGE;
+}
+async function upgradeCli(options, dryRun) {
+  const runner = options.commandRunner ?? defaultCommandRunner;
+  const packageName = resolveCliPackage(options);
+  const tag = resolveTag(options);
+  const target = `${packageName}@${tag}`;
+  const command = ["npm", "install", "-g", target];
+  if (options.repair === true) {
+    command.push("--force");
+  }
+  const beforeVersion = await readCurrentVersion();
+  const planned = {
+    requested: true,
+    status: "planned",
+    package: packageName,
+    target,
+    command,
+    before_version: beforeVersion,
+    repair: options.repair === true
+  };
+  if (dryRun) {
+    return planned;
+  }
+  try {
+    await runner(command[0], command.slice(1));
+    const verified = await runner("pm", ["--version"]);
+    return {
+      ...planned,
+      status: "updated",
+      after_version: verified.stdout.trim() || void 0
+    };
+  } catch (error) {
+    return {
+      ...planned,
+      status: "failed",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function isLocalNpmSpec(spec) {
+  return path.isAbsolute(spec) || spec.startsWith(".") || spec.startsWith("..") || spec.startsWith("file:");
+}
+function resolvePackageInstallSource(source, tag) {
+  if (source.kind === "npm") {
+    const rawSpec = source.input.startsWith("npm:") ? source.input.slice("npm:".length).trim() : source.input.trim();
+    if (!isLocalNpmSpec(rawSpec) && source.package && source.package.trim().length > 0) {
+      return `npm:${source.package.trim()}@${tag}`;
+    }
+    return source.input.startsWith("npm:") ? source.input : `npm:${source.input}`;
+  }
+  return source.input;
+}
+async function resolveRunnablePackageSource(source, tag) {
+  const installSource = resolvePackageInstallSource(source, tag);
+  if (source.kind !== "local") {
+    return installSource;
+  }
+  if (await pathExists(installSource)) {
+    return installSource;
+  }
+  if (await pathExists(source.location)) {
+    return source.location;
+  }
+  return installSource;
+}
+function packageCommandFor(source, installSource, scope, ref) {
+  const command = ["pm", "install", installSource, scope === "global" ? "--global" : "--project"];
+  if (source.kind === "github" && ref && ref.trim().length > 0) {
+    command.push("--ref", ref.trim());
+  }
+  return command;
+}
+async function readManagedRecords(scope, global2) {
+  const roots = resolveRoots(scope, global2);
+  const managedState = await readManagedExtensionState(roots.selected_root);
+  return managedState.state.entries.filter((entry) => entry.scope === scope);
+}
+async function refreshManagedRecord(scope, global2, record) {
+  const records = await readManagedRecords(scope, global2);
+  return records.find((candidate) => packageRecordMatchesTarget(candidate, record.name)) ?? records.find((candidate) => normalizeTarget(candidate.directory) === normalizeTarget(record.directory));
+}
+async function upgradePackageRecord(record, options, global2, scope, dryRun) {
+  const tag = resolveTag(options);
+  const installSource = await resolveRunnablePackageSource(record.source, tag);
+  const command = packageCommandFor(record.source, installSource, scope, record.source.ref);
+  const planned = {
+    name: record.name,
+    directory: record.directory,
+    scope,
+    source: record.source,
+    status: "planned",
+    command,
+    previous_version: record.manifest_version
+  };
+  if (dryRun) {
+    return planned;
+  }
+  try {
+    await runExtension(installSource, {
+      install: true,
+      project: scope === "project",
+      global: scope === "global",
+      ref: record.source.kind === "github" ? record.source.ref : void 0
+    }, global2);
+    const refreshed = await refreshManagedRecord(scope, global2, record);
+    return {
+      ...planned,
+      status: "updated",
+      installed_version: refreshed?.manifest_version
+    };
+  } catch (error) {
+    return {
+      ...planned,
+      status: "failed",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function summarize(cli, packages, includeCli, includePackages) {
+  const statuses = [includeCli ? cli.status : void 0, ...packages.map((entry) => entry.status)].filter((value) => typeof value === "string");
+  return {
+    requested_cli: includeCli,
+    requested_packages: includePackages,
+    planned: statuses.filter((status) => status === "planned").length,
+    updated: statuses.filter((status) => status === "updated").length,
+    skipped: statuses.filter((status) => status === "skipped").length,
+    failed: statuses.filter((status) => status === "failed").length
+  };
+}
+async function runUpgrade(target, options, global2) {
+  if (options.cliOnly === true && options.packagesOnly === true) {
+    throw new PmCliError('Options "--cli-only" and "--packages-only" are mutually exclusive.', EXIT_CODE.USAGE);
+  }
+  const scope = resolveScope(options);
+  const dryRun = options.dryRun === true;
+  const normalizedTarget = typeof target === "string" && target.trim().length > 0 ? target.trim() : void 0;
+  if (options.cliOnly === true && normalizedTarget) {
+    throw new PmCliError('A package target cannot be used with "--cli-only".', EXIT_CODE.USAGE);
+  }
+  const includeCli = options.packagesOnly === true || normalizedTarget ? false : true;
+  const includePackages = options.cliOnly === true ? false : true;
+  const cli = includeCli ? await upgradeCli(options, dryRun) : {
+    requested: false,
+    status: "skipped",
+    package: resolveCliPackage(options),
+    target: `${resolveCliPackage(options)}@${resolveTag(options)}`,
+    command: ["npm", "install", "-g", `${resolveCliPackage(options)}@${resolveTag(options)}`],
+    repair: options.repair === true,
+    reason: "not_requested"
+  };
+  let packageRecords = includePackages ? await readManagedRecords(scope, global2) : [];
+  if (normalizedTarget) {
+    packageRecords = packageRecords.filter((entry) => packageRecordMatchesTarget(entry, normalizedTarget));
+    if (packageRecords.length === 0) {
+      throw new PmCliError(`Managed package "${normalizedTarget}" was not found in ${scope} scope.`, EXIT_CODE.NOT_FOUND);
+    }
+  }
+  const packages = [];
+  for (const record of packageRecords) {
+    packages.push(await upgradePackageRecord(record, options, global2, scope, dryRun));
+  }
+  const summary = summarize(cli, packages, includeCli, includePackages);
+  return {
+    ok: summary.failed === 0,
+    action: "upgrade",
+    dry_run: dryRun,
+    scope,
+    target: normalizedTarget,
+    cli,
+    packages,
+    summary
+  };
+}
 
 export {
   runConfig,
-  _testOnlyConfigCommand
+  runUpgrade
 };
-//# sourceMappingURL=chunk-W6DYWXPQ.js.map
+//# sourceMappingURL=chunk-P2WE5KCU.js.map