@unbrained/pm-cli 2026.7.8 → 2026.7.10

package/dist/cli/commands/extension.d.ts

@@ -260,7 +260,7 @@ declare function resolveCommandDiscoveryPackageName(extensionName: string, sourc
 declare function buildInstallCommandDiscovery(extensionName: string, source: ManagedExtensionSource, commandSummary: {
     command_paths: string[];
     action_paths: string[];
-}): Record<string, unknown>;
+}, activationFailure?: ActivationFailureDiagnostic): Record<string, unknown>;
 declare function collectActivationFailureDiagnostics(failures: ActivationFailureEntry[]): ActivationFailureDiagnostic[];
 declare function findActivationFailureByName(extensionName: string, failures: ActivationFailureDiagnostic[], layer?: ExtensionScope): ActivationFailureDiagnostic | undefined;
 declare function resolveInstallRuntimeActivationStatus(extensionName: string, scope: ExtensionScope, runtimeInstalled: ManagedExtensionSummary[], installActivationFailure: ActivationFailureDiagnostic | undefined): ExtensionActivationStatus;

package/dist/cli/commands/extension.js

@@ -4,13 +4,14 @@
  * Implements the pm extension command surface and its agent-facing runtime behavior.
  */
 
-!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]="0489ce7c-9aeb-586f-a972-70cb1bfa6fc8")}catch(e){}}();
+!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]="87a4158d-15a1-5df7-8893-c55bae10a16a")}catch(e){}}();
 import { execFile } from "node:child_process";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
-import { activateExtensions, loadExtensions, nextExtensionReloadToken } from "../../core/extensions/index.js";
+import { activateExtensions, createSerialQueue, loadExtensions, nextExtensionReloadToken } from "../../core/extensions/index.js";
 import { resolveExtensionRoots } from "../../core/extensions/loader.js";
 import { pathExists } from "../../core/fs/fs-utils.js";
 import { isPathWithinDirectory } from "../../core/fs/path-utils.js";
@@ -635,6 +636,7 @@ async function listInstalledExtensions(extensionsRoot, scope, settings, state) {
         warnings: warnings.sort((left, right) => left.localeCompare(right)),
     };
 }
+const extensionRuntimeProbeQueue = createSerialQueue();
 function summarizeRuntimeCommandPathsForExtension(extensionName, installed) {
     const normalizedName = normalizeExtensionNameForMatch(extensionName);
     const entry = installed.find((candidate) => normalizeExtensionNameForMatch(candidate.name) === normalizedName);
@@ -652,17 +654,23 @@ function resolveCommandDiscoveryPackageName(extensionName, source) {
     }
     return extensionName;
 }
-function buildInstallCommandDiscovery(extensionName, source, commandSummary) {
+function buildInstallCommandDiscovery(extensionName, source, commandSummary, activationFailure) {
     const helpCommands = commandSummary.command_paths.map((commandPath) => `pm ${commandPath} --help`);
+    const sdkDependencyMissing = activationFailure?.error.toLowerCase().includes("@unbrained/pm-cli") === true;
+    const nextSteps = commandSummary.command_paths.length > 0
+        ? [...helpCommands]
+        : ["Run pm package doctor --project --detail deep if expected package commands are missing."];
+    if (sdkDependencyMissing) {
+        nextSteps.unshift("Install @unbrained/pm-cli in the target workspace so declarative package runtime imports resolve, then reinstall the package.");
+    }
     return {
         package_name: resolveCommandDiscoveryPackageName(extensionName, source),
         extension_name: extensionName,
         command_paths: commandSummary.command_paths,
         action_paths: commandSummary.action_paths,
         help_commands: helpCommands,
-        next_steps: commandSummary.command_paths.length > 0
-            ? helpCommands
-            : ["Run pm package doctor --project --detail deep if expected package commands are missing."],
+        next_steps: nextSteps,
+        ...(sdkDependencyMissing ? { sdk_dependency_status: "missing" } : {}),
     };
 }
 function summarizeActivationFailureForDiagnostics(failure) {
@@ -702,24 +710,48 @@ function resolveInstallRuntimeActivationStatus(extensionName, scope, runtimeInst
     return runtimeInstalledExtension?.activation_status ?? (installActivationFailure ? "failed" : "unknown");
 }
 async function probeRuntimeCommandPathsForInstall(pmRoot, settings, refreshedInstalled, global) {
-    const loadResult = await loadExtensions({
-        pmRoot,
-        settings,
-        cwd: process.cwd(),
-        noExtensions: global.noExtensions === true,
-        reload_token: nextExtensionReloadToken(),
-        cache_bust: true,
-    });
-    const activationResult = await activateExtensions({
-        ...loadResult,
-        loaded: loadResult.loaded,
+    return extensionRuntimeProbeQueue.enqueue(async () => {
+        const originalPackageRoot = process.env.PM_CLI_PACKAGE_ROOT;
+        process.env.PM_CLI_PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../..");
+        try {
+            const loadResult = await loadExtensions({
+                pmRoot,
+                settings,
+                cwd: process.cwd(),
+                noExtensions: global.noExtensions === true,
+                reload_token: nextExtensionReloadToken(),
+                cache_bust: true,
+            });
+            const activationResult = await activateExtensions({
+                ...loadResult,
+                loaded: loadResult.loaded,
+            });
+            const runtimeFailures = [
+                ...loadResult.failed.map((failure) => ({
+                    layer: failure.layer,
+                    name: failure.name,
+                    entry_path: failure.entry_path,
+                    error: failure.error,
+                })),
+                ...collectActivationFailureDiagnostics(activationResult.failed),
+            ];
+            return {
+                installed: applyDoctorRuntimeActivationState(refreshedInstalled, loadResult, activationResult),
+                warnings: [...loadResult.warnings, ...activationResult.warnings],
+                activation_failures: runtimeFailures,
+                extensions_disabled: loadResult.disabled_by_flag,
+                item_type_registrations: activationResult.registrations.item_types,
+            };
+        }
+        finally {
+            if (originalPackageRoot === undefined) {
+                delete process.env.PM_CLI_PACKAGE_ROOT;
+            }
+            else {
+                process.env.PM_CLI_PACKAGE_ROOT = originalPackageRoot;
+            }
+        }
     });
-    return {
-        installed: applyDoctorRuntimeActivationState(refreshedInstalled, loadResult, activationResult),
-        warnings: [...loadResult.warnings, ...activationResult.warnings],
-        activation_failures: collectActivationFailureDiagnostics(activationResult.failed),
-        item_type_registrations: activationResult.registrations.item_types,
-    };
 }
 async function checkGithubUpdate(source, gitCommandRunner = runGitCommand) {
     const checkedAt = nowIso();
@@ -1028,9 +1060,9 @@ export async function runExtension(target, options, global) {
     const scope = resolveScope(options);
     const resolvedRoots = resolveExtensionRootsForScope(scope, global);
     const warnings = [];
-    const withResult = (details) => {
+    const withResult = (details, ok = true) => {
         const result = {
-            ok: true,
+            ok,
             action,
             scope,
             roots: action === "catalog" && typeof options.fields === "string" && options.fields.trim().length > 0
@@ -1104,6 +1136,9 @@ async function runExtensionInitAction(ctx) {
                 : [
                     `Install type-check dependencies: cd ${quotedShellTargetPath}, then run "npm install -D typescript @types/node @unbrained/pm-cli"`,
                 ]),
+            ...(options.vocabulary === "package" && options.declarative === true
+                ? ["Ensure the target workspace can resolve @unbrained/pm-cli before installing this declarative package."]
+                : []),
             `Install the scaffold: ${options.vocabulary === "package" ? "pm install --project" : "pm extension --install --project"} ${quotedTargetPath}`,
             `Smoke-test command path: pm ${scaffold.command_name}`,
             ...(options.vocabulary === "package"
@@ -1279,6 +1314,24 @@ async function performExtensionInstallUnderLock(ctx, input) {
     const commandSummary = summarizeRuntimeCommandPathsForExtension(validated.manifest.name, runtimeProbe.installed);
     const installActivationFailure = findActivationFailureByName(validated.manifest.name, runtimeProbe.activation_failures, scope);
     const runtimeActivationStatus = resolveInstallRuntimeActivationStatus(validated.manifest.name, scope, runtimeProbe.installed, installActivationFailure);
+    const activated = !runtimeProbe.extensions_disabled &&
+        runtimeActivationStatus !== "failed";
+    if (!activated) {
+        warnings.push(`extension_install_activation_failed:${scope}:${validated.manifest.name}:${runtimeActivationStatus}`);
+    }
+    const verification = {
+        status: activated ? "ok" : "degraded",
+        target_pm_root: resolvedRoots.pm_root,
+        activation_status: runtimeActivationStatus,
+        activated,
+        registered_commands: commandSummary.command_paths,
+        registered_actions: commandSummary.action_paths,
+        registered_item_types: installedItemTypeDefinitions,
+        health: {
+            status: activated ? "ok" : "degraded",
+            blocking_failure_count: activated ? 0 : 1,
+        },
+    };
     return withResult({
         extension: {
             name: validated.manifest.name,
@@ -1291,18 +1344,19 @@ async function performExtensionInstallUnderLock(ctx, input) {
         destination_path: destinationDirectory,
         overwritten: destinationExists && !installInPlace,
         installed_in_place: installInPlace,
-        activated: true,
+        activated,
         settings_changed: activationChanged,
         runtime_activation_status: runtimeActivationStatus,
         command_paths: commandSummary.command_paths,
         action_paths: commandSummary.action_paths,
-        command_discovery: buildInstallCommandDiscovery(validated.manifest.name, sourceRecord, commandSummary),
+        command_discovery: buildInstallCommandDiscovery(validated.manifest.name, sourceRecord, commandSummary, installActivationFailure),
+        verification,
         activation_diagnostics: {
             failed_count: runtimeProbe.activation_failures.length,
             failed: runtimeProbe.activation_failures,
             installed_extension_failed: installActivationFailure ?? null,
         },
-    });
+    }, activated);
 }
 async function runExtensionInstallAction(ctx) {
     const { action, normalizedTarget, resolvedRoots, warnings, options, global, withResult } = ctx;
@@ -1323,9 +1377,11 @@ async function runExtensionInstallAction(ctx) {
         for (const entry of packages) {
             warnings.push(...entry.result.warnings);
         }
+        const installedAll = packages.every((entry) => entry.result.ok);
         return withResult({
-            installed_all: true,
-            installed_count: packages.length,
+            installed_all: installedAll,
+            installed_count: packages.filter((entry) => entry.result.ok).length,
+            failed_count: packages.filter((entry) => !entry.result.ok).length,
             packages: packages.map((entry) => ({
                 alias: entry.alias,
                 ok: entry.result.ok,
@@ -1337,9 +1393,12 @@ async function runExtensionInstallAction(ctx) {
                 command_paths: entry.result.details.command_paths,
                 action_paths: entry.result.details.action_paths,
                 command_discovery: entry.result.details.command_discovery,
+                verification: entry.result.details.verification,
+                runtime_activation_status: entry.result.details.runtime_activation_status,
+                activation_diagnostics: entry.result.details.activation_diagnostics,
                 warnings: entry.result.warnings,
             })),
-        });
+        }, installedAll);
     }
     /* c8 ignore start -- github/local alias-source split is exercised in install-action integration tests */
     const bundledAliasSource = typeof githubOption === "string" ? null : await resolveBundledExtensionAliasSource(explicitSourceInput);
@@ -2052,4 +2111,4 @@ export const _testOnly = {
     withExtensionInstallLock,
 };
 //# sourceMappingURL=extension.js.map
-//# debugId=0489ce7c-9aeb-586f-a972-70cb1bfa6fc8
+//# debugId=87a4158d-15a1-5df7-8893-c55bae10a16a