@unbrained/pm-cli 2026.6.8 → 2026.6.9

package/dist/core/extensions/loader.js

@@ -1,5 +1,5 @@
 
-!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]="54365547-c7be-5bd4-be2e-ca02f27aa365")}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]="e5c4c469-142a-5854-82ca-a920130d2104")}catch(e){}}();
 import fs from "node:fs/promises";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
@@ -8,6 +8,8 @@ import { isPathWithinDirectory } from "../fs/path-utils.js";
 import { resolvePmPackageRootFromModule } from "../packages/root.js";
 import { resolveGlobalPmRoot } from "../store/paths.js";
 import { asRecordLoose } from "../shared/primitives.js";
+import { flattenFlagListValue, isFlagDefaultValueCoercible, resolveFlagValueKind } from "./flag-value-types.js";
+import { KNOWN_ITEM_FIELD_TYPES, normalizeItemFieldType, suggestKnownItemFieldType } from "./item-field-types.js";
 // Cohesive helper groups now live in sibling modules. They are imported for the
 // discovery/activation code that stays here and re-exported below so existing
 // import sites (sdk/index.ts, commands/extension.ts, health.ts, tests, …) keep
@@ -19,7 +21,7 @@ import { normalizeCommandName, cloneContextSnapshot, } from "./extension-runtime
 export { parseUnknownExtensionCapabilityWarning, parseLegacyExtensionCapabilityAliasWarning, } from "./extension-capability-aliases.js";
 export { createEmptyExtensionHookRegistry, createEmptyExtensionCommandRegistry, createEmptyExtensionParserRegistry, createEmptyExtensionPreflightRegistry, createEmptyExtensionServiceRegistry, createEmptyExtensionRendererRegistry, createEmptyExtensionRegistrationRegistry, } from "./extension-registries.js";
 export { runBeforeCommandHooks, runAfterCommandHooks, runOnWriteHooks, runOnReadHooks, runOnIndexHooks, runCommandHandler, runParserOverride, runPreflightOverride, runServiceOverrideSync, runServiceOverride, runCommandOverride, runRendererOverride, } from "./extension-hook-runtime.js";
-import { KNOWN_EXTENSION_SERVICE_NAMES, createDefaultExtensionGovernancePolicy, } from "./extension-types.js";
+import { KNOWN_EXTENSION_CAPABILITIES, KNOWN_EXTENSION_SERVICE_NAMES, createDefaultExtensionGovernancePolicy, } from "./extension-types.js";
 export * from "./extension-types.js";
 const DEFAULT_EXTENSION_PRIORITY = 100;
 let currentPmCliVersionPromise = null;
@@ -727,24 +729,82 @@ export async function loadExtensions(options) {
         failed,
     };
 }
+function toActivatableExtension(source) {
+    // Bind to `source` so a module/default-export authored with methods (or a class
+    // instance) keeps its `this` across both lifecycle calls — `activate` is a
+    // method call on a fresh object and `deactivate` is invoked bare, so without
+    // binding the two would see different (or undefined) `this`.
+    const activate = source.activate;
+    const activatable = {
+        activate: activate.bind(source),
+    };
+    if (typeof source.deactivate === "function") {
+        const deactivate = source.deactivate;
+        activatable.deactivate = deactivate.bind(source);
+    }
+    return activatable;
+}
 function resolveActivatableExtension(module) {
     const moduleRecord = asRecordLoose(module);
     if (!moduleRecord) {
         return null;
     }
     if (typeof moduleRecord.activate === "function") {
-        return {
-            activate: moduleRecord.activate,
-        };
+        return toActivatableExtension(moduleRecord);
     }
     const defaultExport = asRecordLoose(moduleRecord.default);
     if (defaultExport && typeof defaultExport.activate === "function") {
-        return {
-            activate: defaultExport.activate,
-        };
+        return toActivatableExtension(defaultExport);
     }
     return null;
 }
+/**
+ * Run the optional `deactivate` teardown hook for every loaded extension that
+ * exports one. Best-effort: a throwing teardown is captured as a warning and a
+ * failure entry rather than propagated, so one extension cannot block another's
+ * cleanup. Hosts call this on shutdown/reload (e.g. the MCP server between
+ * native-action requests) to release resources opened during `activate`.
+ *
+ * Pass the `activationResult` to skip extensions whose `activate` failed — they
+ * never fully initialized, so (VS Code-style) their `deactivate` must not run.
+ * Teardowns run concurrently so one slow hook cannot serialize the rest; the
+ * returned warnings/failures preserve loaded order.
+ */
+export async function deactivateExtensions(loadResult, activationResult) {
+    const failedActivationKeys = new Set((activationResult?.failed ?? []).map((entry) => `${entry.layer}:${entry.name}`));
+    const targets = [];
+    for (const extension of loadResult.loaded) {
+        if (failedActivationKeys.has(`${extension.layer}:${extension.name}`)) {
+            continue;
+        }
+        const activatable = resolveActivatableExtension(extension.module);
+        if (!activatable || typeof activatable.deactivate !== "function") {
+            continue;
+        }
+        targets.push({ extension, deactivate: activatable.deactivate });
+    }
+    const outcomes = await Promise.all(targets.map(async ({ extension, deactivate }) => {
+        try {
+            await deactivate();
+            return { ok: true };
+        }
+        catch (error) {
+            return { ok: false, layer: extension.layer, name: extension.name, error: formatUnknownError(error) };
+        }
+    }));
+    const warnings = [];
+    const failed = [];
+    let deactivated = 0;
+    for (const outcome of outcomes) {
+        if (outcome.ok) {
+            deactivated += 1;
+            continue;
+        }
+        warnings.push(`extension_deactivate_failed:${outcome.layer}:${outcome.name}`);
+        failed.push({ layer: outcome.layer, name: outcome.name, error: outcome.error });
+    }
+    return { deactivated, warnings, failed };
+}
 function isOutputRendererFormat(value) {
     return value === "toon" || value === "json";
 }
@@ -873,6 +933,25 @@ function assertOptionalStringField(name, value) {
         throw new TypeError(`${name} must be a non-empty string when provided`);
     }
 }
+function isFlagDefaultScalar(value) {
+    return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function assertOptionalFlagDefaultField(name, value) {
+    if (value === undefined) {
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const [index, item] of value.entries()) {
+            if (!isFlagDefaultScalar(item)) {
+                throw new TypeError(`${name}[${index}] must be a string, number, or boolean`);
+            }
+        }
+        return;
+    }
+    if (!isFlagDefaultScalar(value)) {
+        throw new TypeError(`${name} must be a string, number, or boolean, or an array of these when provided`);
+    }
+}
 function assertOptionalStringArrayField(name, value) {
     if (value === undefined) {
         return;
@@ -992,6 +1071,42 @@ function validateFlagDefinitions(flags) {
         assertOptionalBooleanField(`registerFlags flags[${index}].required`, record.required);
         assertOptionalBooleanField(`registerFlags flags[${index}].enabled`, record.enabled);
         assertOptionalBooleanField(`registerFlags flags[${index}].visible`, record.visible);
+        assertOptionalBooleanField(`registerFlags flags[${index}].list`, record.list);
+        assertOptionalFlagDefaultField(`registerFlags flags[${index}].default`, record.default);
+        if (Array.isArray(record.default) && record.list !== true) {
+            throw new TypeError(`registerFlags flags[${index}].default cannot be an array unless list is true.`);
+        }
+        assertFlagValueTypeAndDefault(`registerFlags flags[${index}]`, record);
+    }
+}
+/**
+ * Reject a declared `value_type`/`type` that is not a known flag value kind, and
+ * a `default` whose value(s) would not cleanly coerce under that kind — so the
+ * typed-flag contract is enforced at registration instead of silently leaving
+ * an untyped value to surface at use time.
+ */
+function assertFlagValueTypeAndDefault(label, record) {
+    const declaredType = (typeof record.value_type === "string" ? record.value_type : undefined) ??
+        (typeof record.type === "string" ? record.type : undefined);
+    if (declaredType === undefined) {
+        return;
+    }
+    const kind = resolveFlagValueKind(declaredType);
+    if (kind === null) {
+        throw new TypeError(`${label} value_type "${declaredType}" is not a known flag value type (expected one of: string, number, boolean).`);
+    }
+    if (record.default === undefined) {
+        return;
+    }
+    // For list flags, validate the default exactly as the runtime will see it —
+    // comma-joined strings and nested arrays are flattened first — so a valid
+    // default like `value_type: "number", default: "10,20"` is not wrongly rejected.
+    const defaults = record.list === true ? flattenFlagListValue(record.default) : [record.default];
+    for (const [defaultIndex, defaultValue] of defaults.entries()) {
+        if (!isFlagDefaultValueCoercible(defaultValue, kind)) {
+            const suffix = defaults.length > 1 ? `default[${defaultIndex}]` : "default";
+            throw new TypeError(`${label}.${suffix} (${JSON.stringify(defaultValue)}) is not coercible to ${kind}.`);
+        }
     }
 }
 function validateItemFieldDefinitions(fields) {
@@ -1001,7 +1116,13 @@ function validateItemFieldDefinitions(fields) {
     for (const [index, raw] of fields.entries()) {
         const record = asRegistrationRecord(`registerItemFields fields[${index}]`, raw);
         assertNonEmptyString(`registerItemFields fields[${index}].name`, record.name);
-        assertNonEmptyString(`registerItemFields fields[${index}].type`, record.type);
+        const fieldType = assertNonEmptyString(`registerItemFields fields[${index}].type`, record.type);
+        if (normalizeItemFieldType(fieldType) === null) {
+            const suggestion = suggestKnownItemFieldType(fieldType);
+            const hint = suggestion ? ` Did you mean "${suggestion}"?` : "";
+            throw new TypeError(`registerItemFields fields[${index}].type "${fieldType}" is not a known field type ` +
+                `(expected one of: ${KNOWN_ITEM_FIELD_TYPES.join(", ")}).${hint}`);
+        }
         assertOptionalBooleanField(`registerItemFields fields[${index}].optional`, record.optional);
     }
 }
@@ -1102,6 +1223,15 @@ function assertExtensionCapability(extension, capability, method) {
     }
 }
 function createExtensionApi(extension, hooks, commands, parsers, preflight, services, renderers, registrations, activationWarnings, policy) {
+    const selfIdentity = Object.freeze({
+        name: extension.name,
+        layer: extension.layer,
+        version: extension.version,
+        capabilities: Object.freeze((extension.capabilities ?? []).filter((capability) => KNOWN_EXTENSION_CAPABILITIES.includes(capability))),
+        pm_min_version: extension.pm_min_version,
+        pm_max_version: extension.pm_max_version,
+        source_package: extension.source_package,
+    });
     const extensionRef = {
         layer: extension.layer,
         name: extension.name,
@@ -1552,6 +1682,7 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
         });
     };
     return {
+        extension: selfIdentity,
         registerCommand,
         registerParser,
         registerPreflight,
@@ -1769,4 +1900,4 @@ export async function activateExtensions(loadResult) {
     };
 }
 //# sourceMappingURL=loader.js.map
-//# debugId=54365547-c7be-5bd4-be2e-ca02f27aa365
+//# debugId=e5c4c469-142a-5854-82ca-a920130d2104