@mearl/setup 2.21.0 → 3.0.0-beta.0

package/dist/cli.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
-import { createRequire } from 'node:module';
 import { Command, CommanderError } from 'commander';
 import { installMearlBrowserExtension, isUnsupportedCdpMethodError } from './browserExtension.js';
 import { runMearlLifecycle } from './lifecycle.js';
 import { isMearlReleaseLine } from './version.js';
 import { ensureOfficialPlugin, installPlugins, setupPlugin, uninstallPlugin } from './plugin.js';
 import { installProviderPackage, uninstallProviderPackage, updateProviderPackage, } from './provider.js';
-const require = createRequire(import.meta.url);
-export const SETUP_VERSION = require('../package.json').version;
+import { runPresetCommand } from './preset.js';
+import { prepareSetupPreset } from './presetUpgrade.js';
+import { SETUP_VERSION, SETUP_COMMAND } from './setupVersion.js';
+export { SETUP_VERSION } from './setupVersion.js';
 const baseParsedArgs = () => ({
     help: false,
     skipSkill: false,
@@ -24,6 +25,13 @@ function commanderError(error) {
     return new Error(message);
 }
 export function parseSetupArgs(argv) {
+    if (argv[0] === 'preset') {
+        if (argv[1] === 'apply' && argv.length === 3 && argv[2])
+            return { ...baseParsedArgs(), operation: 'preset', presetCommand: 'apply', presetSource: argv[2] };
+        if ((argv[1] === 'update' || argv[1] === 'status') && argv.length === 2)
+            return { ...baseParsedArgs(), operation: 'preset', presetCommand: argv[1] };
+        throw new Error('preset requires apply <source-url-or-path>, update, or status');
+    }
     if (argv[0] === 'provider') {
         const command = argv[1];
         if ((command === 'install' || command === 'update' || command === 'uninstall') &&
@@ -83,6 +91,7 @@ export function parseSetupArgs(argv) {
             .option('--mcp')
             .option('--target-line <major.minor.x>')
             .option('--skip-skill')
+            .option('--preset <source>')
             .option('-y, --yes')
             .option('--non-interactive');
         if (operation === 'uninstall')
@@ -95,6 +104,10 @@ export function parseSetupArgs(argv) {
             if (options.targetLine && !isMearlReleaseLine(options.targetLine)) {
                 throw new Error('--target-line requires a valid Mearl release line such as 2.3.x');
             }
+            if (operation === 'uninstall' && options.preset)
+                throw new Error('--preset is not available for uninstall');
+            if (options.preset !== undefined && !options.preset.trim())
+                throw new Error('--preset requires a source');
             if (operation === 'uninstall' && options.targetLine) {
                 throw new Error('--target-line is not available for uninstall');
             }
@@ -115,6 +128,7 @@ export function parseSetupArgs(argv) {
                 ...(options.full ? { full: true } : {}),
                 skipSkill: options.skipSkill === true,
                 targetLine: options.targetLine,
+                ...(options.preset ? { presetSource: options.preset } : {}),
                 yes: options.yes === true || options.nonInteractive === true,
             };
         });
@@ -171,6 +185,9 @@ Environment commands:
   uninstall [options]             Uninstall detected or selected environments
 
 Integration commands:
+  preset apply <source>          Apply a preset, synchronize hosts and install declared components
+  preset update                  Update the selected preset, preserving user overrides
+  preset status                  Report actual readiness (exit 3 when synchronization is pending)
   plugin install <arguments...>   Install Skills and register their CLI plugins
   plugin uninstall <name>        Uninstall one CLI plugin
   plugin [name] <path>            Register an existing plugin; name overrides metadata
@@ -187,6 +204,7 @@ Environment options:
   --qoder-cloud                   Manage cloud packages in Qoder pairing mode
   --mcp                           Manage @mearl/mcp-server and its configuration
   --target-line <major.minor.x>   Use the latest packages in one release line
+  --preset <source>               Apply a preset after installing or updating the environment
   --skip-skill                    Keep the independently managed Mearl Skill unchanged
 
 Uninstall options:
@@ -209,9 +227,27 @@ Examples:
   npx @mearl/setup update
   npx @mearl/setup uninstall --full
   npx @mearl/setup plugin uninstall yuque
-  npx @mearl/setup provider install @ali/mearl-provider-brow
+  npx @mearl/setup provider install @example/mearl-provider-brow
   npx @mearl/setup extension --full`;
-    console.log(output);
+    console.log(output.replaceAll('npx @mearl/setup', SETUP_COMMAND));
+}
+async function runSetupLifecycle(options, dependencies) {
+    let preset;
+    const callback = options.operation === 'uninstall' ? undefined : { onPresetStatus: (status) => { preset = status; } };
+    const lifecycle = dependencies.runLifecycle ?? runMearlLifecycle;
+    const ok = callback ? await lifecycle(options, callback) : await lifecycle(options);
+    if (!ok)
+        return 1;
+    if (!preset) {
+        if (options.presetSource)
+            throw new Error('Preset preparation did not complete');
+        return 0;
+    }
+    const actual = await (dependencies.runPreset ?? runPresetCommand)('status');
+    if (actual.revision !== preset.revision)
+        throw new Error('The selected preset changed while setup was running');
+    console.log(JSON.stringify(actual, null, 2));
+    return actual.ready ? 0 : 3;
 }
 export async function main(argv = process.argv.slice(2), interactiveTerminal = process.stdin.isTTY === true && process.stdout.isTTY === true, dependencies = {}) {
     let parsed;
@@ -220,7 +256,7 @@ export async function main(argv = process.argv.slice(2), interactiveTerminal = p
     }
     catch (error) {
         console.error(error instanceof Error ? error.message : String(error));
-        console.error('Run "npx @mearl/setup --help" for usage.');
+        console.error(`Run "${SETUP_COMMAND} --help" for usage.`);
         return 2;
     }
     if (parsed.help) {
@@ -231,6 +267,17 @@ export async function main(argv = process.argv.slice(2), interactiveTerminal = p
         console.log(SETUP_VERSION);
         return 0;
     }
+    if (parsed.operation === 'preset') {
+        try {
+            const result = await (dependencies.runPreset ?? runPresetCommand)(parsed.presetCommand, parsed.presetSource);
+            console.log(JSON.stringify(result, null, 2));
+            return result.ready ? 0 : 3;
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            return 1;
+        }
+    }
     if (parsed.operation === 'plugin') {
         try {
             if (parsed.pluginInstallArgs) {
@@ -250,8 +297,8 @@ export async function main(argv = process.argv.slice(2), interactiveTerminal = p
                 }
                 else if (result.skillName) {
                     console.error(result.entryMissing
-                        ? `Plugin ${parsed.pluginUninstallName} had a missing entry; ali-skills cleanup completed for ${result.skillName}.`
-                        : `Plugin ${parsed.pluginUninstallName} uninstalled with ali-skills skill ${result.skillName}.`);
+                        ? `Plugin ${parsed.pluginUninstallName} had a missing entry; skills cleanup completed for ${result.skillName}.`
+                        : `Plugin ${parsed.pluginUninstallName} uninstalled with skills skill ${result.skillName}.`);
                     if (result.unregisteredNames.length > 1) {
                         console.error(`Removed registrations: ${result.unregisteredNames.join(', ')}`);
                     }
@@ -302,6 +349,15 @@ export async function main(argv = process.argv.slice(2), interactiveTerminal = p
             console.error('Non-interactive input detected. Re-run with --yes or --non-interactive.');
             return 2;
         }
+        if (parsed.full) {
+            try {
+                await (dependencies.preparePreset ?? prepareSetupPreset)({});
+            }
+            catch (error) {
+                console.error(`Preset preparation: ${error instanceof Error ? error.message : String(error)}`);
+                return 1;
+            }
+        }
         let extensionInstalled = false;
         let extensionFailureIsTerminal = false;
         try {
@@ -325,11 +381,11 @@ export async function main(argv = process.argv.slice(2), interactiveTerminal = p
                 if (result.cdpError) {
                     console.error(`CDP installation failed: ${result.cdpError}`);
                     if (isUnsupportedCdpMethodError(result.cdpError)) {
-                        console.error('This Chrome version does not support installing extensions through CDP. Update Chrome to version 145 or later, then rerun: npx @mearl/setup extension');
+                        console.error(`This Chrome version does not support installing extensions through CDP. Update Chrome to version 145 or later, then rerun: ${SETUP_COMMAND} extension`);
                         extensionFailureIsTerminal = true;
                     }
                     else {
-                        console.error('Open chrome://inspect/#remote-debugging, enable remote debugging, approve the connection, then rerun: npx @mearl/setup extension');
+                        console.error(`Open chrome://inspect/#remote-debugging, enable remote debugging, approve the connection, then rerun: ${SETUP_COMMAND} extension`);
                         extensionFailureIsTerminal = parsed.yes;
                     }
                 }
@@ -340,26 +396,26 @@ export async function main(argv = process.argv.slice(2), interactiveTerminal = p
         }
         if (!parsed.full || extensionFailureIsTerminal)
             return extensionInstalled ? 0 : 1;
-        let localInstalled = false;
+        let localStatus = 1;
         try {
-            localInstalled = await (dependencies.runLifecycle ?? runMearlLifecycle)({
+            localStatus = await runSetupLifecycle({
                 operation: 'install',
                 profiles: ['local'],
                 skipSkill: false,
                 yes: parsed.yes,
-            });
+            }, dependencies);
         }
         catch (error) {
             console.error(error instanceof Error ? error.message : String(error));
         }
-        return extensionInstalled && localInstalled ? 0 : 1;
+        return extensionInstalled ? localStatus : 1;
     }
     if (!interactiveTerminal && !parsed.yes && parsed.operation !== 'update') {
         console.error('Non-interactive input detected. Re-run with --yes or --non-interactive.');
         return 2;
     }
     try {
-        const ok = await (dependencies.runLifecycle ?? runMearlLifecycle)({
+        const options = {
             operation: parsed.operation,
             profiles: parsed.profiles,
             cloudMode: parsed.cloudMode,
@@ -367,8 +423,9 @@ export async function main(argv = process.argv.slice(2), interactiveTerminal = p
             skipSkill: parsed.skipSkill,
             targetLine: parsed.targetLine,
             yes: parsed.yes,
-        });
-        return ok ? 0 : 1;
+            ...(parsed.presetSource ? { presetSource: parsed.presetSource } : {}),
+        };
+        return await runSetupLifecycle(options, dependencies);
     }
     catch (error) {
         console.error(error instanceof Error ? error.message : String(error));

package/dist/index.d.ts

@@ -7,8 +7,10 @@ export type { MearlLifecycleDependencies, MearlLifecycleOperation, MearlLifecycl
 export { MEARL_PROFILES, detectMearlProfiles } from './profiles.js';
 export type { DetectedMearlProfiles, MearlProfile, MearlProfileConfig } from './profiles.js';
 export { MEARL_NATIVE_HOST_NAMES, resolveNativeHostDirectory, uninstallNativeHostArtifacts, } from './nativeHost.js';
+export { PresetInstaller, PresetInstallationStore, createNodePresetLoader, runPresetCommand } from './preset.js';
+export type { PresetInstallReceipt, PresetInstallStatus, PresetInstallerOptions, PresetApplyOptions, StagedPresetInstallation, PresetHostTarget, PresetHostStatus, PresetBrowserHostStatus, PresetComponentHostStatus, PresetComponentStatus } from './preset.js';
 export { compareMearlReleaseLines, compareMearlReleaseVersions, isMearlReleaseLine, isMearlReleaseVersion, isMearlReleaseVersionInLine, mearlReleaseLineForVersion, parseMearlReleaseLine, parseMearlReleaseVersion, } from './version.js';
 export type { MearlReleaseLine, MearlReleaseVersion } from './version.js';
-export { installProviderPackage, parseProviderPackageSpec, uninstallProviderPackage, updateProviderPackage, } from './provider.js';
+export { installProviderPackage, inspectProviderPackage, parseProviderPackageSpec, uninstallProviderPackage, updateProviderPackage, } from './provider.js';
 export type { ProviderSetupDependencies, ProviderSetupResult } from './provider.js';
 export type { NativeHostCleanupDependencies, NativeHostCleanupOptions, NativeHostIntegrationMode, } from './nativeHost.js';

package/dist/index.js

@@ -3,5 +3,6 @@ export { BrowserExtensionConflictError, extensionArchiveUrl, fetchBrowserExtensi
 export { runMearlLifecycle } from './lifecycle.js';
 export { MEARL_PROFILES, detectMearlProfiles } from './profiles.js';
 export { MEARL_NATIVE_HOST_NAMES, resolveNativeHostDirectory, uninstallNativeHostArtifacts, } from './nativeHost.js';
+export { PresetInstaller, PresetInstallationStore, createNodePresetLoader, runPresetCommand } from './preset.js';
 export { compareMearlReleaseLines, compareMearlReleaseVersions, isMearlReleaseLine, isMearlReleaseVersion, isMearlReleaseVersionInLine, mearlReleaseLineForVersion, parseMearlReleaseLine, parseMearlReleaseVersion, } from './version.js';
-export { installProviderPackage, parseProviderPackageSpec, uninstallProviderPackage, updateProviderPackage, } from './provider.js';
+export { installProviderPackage, inspectProviderPackage, parseProviderPackageSpec, uninstallProviderPackage, updateProviderPackage, } from './provider.js';

package/dist/lifecycle.d.ts

@@ -1,16 +1,19 @@
 import { listPluginNames } from '@mearl/client/plugin';
 import { listInstalledProviders } from '@mearl/provider/host';
-import { runGlobalMearlSkillOperation } from './aliSkills.js';
+import { runGlobalMearlSkillOperation } from './skills.js';
 import { detectGlobalPackage, type PackageManagerInstallation, type PackageDetectionOptions } from './packageManager.js';
 import { type DetectedMearlProfiles, type MearlProfile } from './profiles.js';
 import { uninstallNativeHostArtifacts } from './nativeHost.js';
 import { type CommandRunner } from '@mearl/daemon-core';
-import { installAlibabaInternalPlugins, uninstallAlibabaInternalPlugins } from './internalPlugins.js';
+import { installManagedPlugins, uninstallManagedPlugins } from './managedPlugins.js';
 import { uninstallPlugin } from './plugin.js';
 import { uninstallProviderPackage } from './provider.js';
 import { cleanupUninstalledRuntime } from './runtimeCleanup.js';
+import { prepareSetupPreset } from './presetUpgrade.js';
+import type { PresetInstallStatus } from './preset.js';
 export type MearlLifecycleOperation = 'install' | 'update' | 'uninstall';
 export interface MearlLifecycleOptions {
+    presetSource?: string;
     operation: MearlLifecycleOperation;
     cloudMode?: 'websocket' | 'qoder';
     /** Uninstall every registered CLI plugin and Provider in addition to selected environments. */
@@ -24,19 +27,23 @@ export interface MearlLifecycleOptions {
     env?: NodeJS.ProcessEnv;
 }
 export interface MearlLifecycleDependencies {
+    preparePreset?: typeof prepareSetupPreset;
+    onPresetStatus?: (status: PresetInstallStatus) => void;
+    /** Prepare the selected manager after packages are usable and before Skill operations. */
+    prepareSkills?: () => Promise<void>;
     cleanupRuntime?: typeof cleanupUninstalledRuntime;
     cleanupNativeHost?: typeof uninstallNativeHostArtifacts;
     confirm?: (message: string) => Promise<boolean>;
     detectPackage?: typeof detectGlobalPackage;
     detectProfiles?: (env: NodeJS.ProcessEnv, options?: Pick<PackageDetectionOptions, 'includeLinked'>) => DetectedMearlProfiles;
     existsSync?: (filePath: string) => boolean;
-    installInternalPlugins?: typeof installAlibabaInternalPlugins;
+    installManagedPlugins?: typeof installManagedPlugins;
     listPlugins?: typeof listPluginNames;
     listProviders?: typeof listInstalledProviders;
     resolveInvokingManager?: (env: NodeJS.ProcessEnv) => PackageManagerInstallation;
     runCommand?: CommandRunner;
     runSkillOperation?: typeof runGlobalMearlSkillOperation;
-    uninstallInternalPlugins?: typeof uninstallAlibabaInternalPlugins;
+    uninstallManagedPlugins?: typeof uninstallManagedPlugins;
     uninstallPlugin?: typeof uninstallPlugin;
     uninstallProvider?: typeof uninstallProviderPackage;
     writeLine?: (line: string) => void;

package/dist/lifecycle.js

@@ -1,20 +1,22 @@
+import { SETUP_VERSION } from './setupVersion.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import { createInterface } from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
 import { listPluginNames } from '@mearl/client/plugin';
 import { listInstalledProviders } from '@mearl/provider/host';
-import { runGlobalMearlSkillOperation } from './aliSkills.js';
+import { runGlobalMearlSkillOperation } from './skills.js';
 import { buildGlobalPackageCommand, detectGlobalPackage, resolveInvokingPackageManager, resolvePackageManagerInstallation, } from './packageManager.js';
 import { MEARL_PROFILES, detectMearlProfiles, } from './profiles.js';
 import { uninstallNativeHostArtifacts } from './nativeHost.js';
 import { executableNames, prependCommandPath, runCommand, } from '@mearl/daemon-core';
-import { isMearlReleaseLine } from './version.js';
-import { installAlibabaInternalPlugins, uninstallAlibabaInternalPlugins, } from './internalPlugins.js';
+import { isMearlReleaseLine, mearlPackageSelector } from './version.js';
+import { installManagedPlugins, uninstallManagedPlugins, } from './managedPlugins.js';
 import { uninstallPlugin } from './plugin.js';
 import { uninstallProviderPackage } from './provider.js';
 import { packageRegistryEnvironment } from './npmRegistry.js';
 import { cleanupUninstalledRuntime } from './runtimeCleanup.js';
+import { prepareSetupPreset } from './presetUpgrade.js';
 const LEGACY_CLOUD_CLIENT = '@mearl/cloud-client';
 const UNIFIED_CLIENT = '@mearl/client';
 const PROFILE_ORDER = ['local', 'cloud', 'mcp'];
@@ -273,6 +275,29 @@ export async function runMearlLifecycle(options, dependencies = {}) {
     if (autoUpdateClient && lifecycleSelected.length === 0) {
         writeLine('update targets: client CLI');
     }
+    const selectedUsesClient = autoUpdateClient !== null ||
+        lifecycleSelected.some(profile => CLIENT_PROFILES.includes(profile));
+    const detectedClientCandidate = selectedUsesClient && !autoUpdateClient
+        ? detectPackage(UNIFIED_CLIENT, ['mearl'], packageDetectionOptions)
+        : null;
+    const detectedClient = detectedClientCandidate?.packageName === UNIFIED_CLIENT ? detectedClientCandidate : null;
+    let stagedPreset;
+    if (options.operation !== 'uninstall' && (options.presetSource || !options.targetLine || Number(options.targetLine.split('.')[0]) >= 3) && !dependencies.prepareSkills) {
+        try {
+            stagedPreset = await (dependencies.preparePreset ?? prepareSetupPreset)({
+                source: options.presetSource, env,
+                installed: [
+                    ...lifecycleSelected.flatMap(profile => detected.get(profile) ? [detected.get(profile)] : []),
+                    ...(detectedClient ? [detectedClient] : []),
+                    ...(autoUpdateClient && env.MEARL_AUTO_UPDATE_CLIENT_ROOT ? [{ packageName: UNIFIED_CLIENT, packageRoot: env.MEARL_AUTO_UPDATE_CLIENT_ROOT }] : []),
+                ],
+            });
+        }
+        catch (error) {
+            writeLine(`Preset preparation: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+    }
     let packagesOk = true;
     if (lifecycleSelected.includes('cloud')) {
         const legacyCloudClient = detectPackage(LEGACY_CLOUD_CLIENT, ['mearl-cloud'], packageDetectionOptions);
@@ -290,12 +315,6 @@ export async function runMearlLifecycle(options, dependencies = {}) {
             }
         }
     }
-    const selectedUsesClient = autoUpdateClient !== null ||
-        lifecycleSelected.some(profile => CLIENT_PROFILES.includes(profile));
-    const detectedClientCandidate = selectedUsesClient && !autoUpdateClient
-        ? detectPackage(UNIFIED_CLIENT, ['mearl'], packageDetectionOptions)
-        : null;
-    const detectedClient = detectedClientCandidate?.packageName === UNIFIED_CLIENT ? detectedClientCandidate : null;
     const remainingClientProfiles = selectedUsesClient && options.operation === 'uninstall'
         ? CLIENT_PROFILES.filter(profile => detected.has(profile) && !lifecycleSelected.includes(profile))
         : [];
@@ -305,7 +324,7 @@ export async function runMearlLifecycle(options, dependencies = {}) {
             detected.get('local') ??
             detected.get('cloud') ??
             resolveInvokingManager(env);
-        const sharedClient = await runPackageOperation(clientInstallation, options.operation, [UNIFIED_CLIENT], options.targetLine, runner, env, 'Packages (shared client)', writeLine);
+        const sharedClient = await runPackageOperation(clientInstallation, options.operation, [UNIFIED_CLIENT], mearlPackageSelector(SETUP_VERSION, options.targetLine), runner, env, 'Packages (shared client)', writeLine);
         if (!sharedClient.ok) {
             writeLine('Mearl setup incomplete. Review the messages above.');
             return false;
@@ -345,7 +364,7 @@ export async function runMearlLifecycle(options, dependencies = {}) {
         if (packages.length === 0) {
             continue;
         }
-        const packageResult = await runPackageOperation(installation, packageOperation, packages, options.targetLine, runner, env, `Packages (${profile})`, writeLine);
+        const packageResult = await runPackageOperation(installation, packageOperation, packages, mearlPackageSelector(SETUP_VERSION, options.targetLine), runner, env, `Packages (${profile})`, writeLine);
         if (!packageResult.ok) {
             packagesOk = false;
             continue;
@@ -403,6 +422,20 @@ export async function runMearlLifecycle(options, dependencies = {}) {
             }
         }
     }
+    if (packagesOk && options.operation !== 'uninstall' && (stagedPreset || dependencies.prepareSkills)) {
+        try {
+            if (stagedPreset) {
+                const status = await stagedPreset.activate();
+                dependencies.onPresetStatus?.(status);
+            }
+            else
+                await dependencies.prepareSkills();
+        }
+        catch (error) {
+            writeLine(`Skill preparation: ${error instanceof Error ? error.message : String(error)}`);
+            packagesOk = false;
+        }
+    }
     const selectedUsesSkill = lifecycleSelected.some(profile => MEARL_PROFILES[profile].usesSkill);
     const remainingSkillProfiles = ['local', 'cloud'].filter(profile => detected.has(profile) && !lifecycleSelected.includes(profile));
     let runStandaloneSkill = true;
@@ -415,7 +448,7 @@ export async function runMearlLifecycle(options, dependencies = {}) {
             (options.operation !== 'uninstall' && options.targetLine === undefined))) {
         try {
             if (options.operation === 'uninstall') {
-                const result = await (dependencies.uninstallInternalPlugins ?? uninstallAlibabaInternalPlugins)({
+                const result = await (dependencies.uninstallManagedPlugins ?? uninstallManagedPlugins)({
                     env,
                     includeMearlSkill: true,
                     runCommand: runner,
@@ -429,7 +462,7 @@ export async function runMearlLifecycle(options, dependencies = {}) {
                 }
             }
             else {
-                const result = await (dependencies.installInternalPlugins ?? installAlibabaInternalPlugins)({
+                const result = await (dependencies.installManagedPlugins ?? installManagedPlugins)({
                     env,
                     includeMearlSkill: true,
                     mearlSkillOperation: options.operation,
@@ -445,7 +478,7 @@ export async function runMearlLifecycle(options, dependencies = {}) {
             }
         }
         catch (error) {
-            writeLine(`Internal skill batch: ${error instanceof Error ? error.message : String(error)}; failed.`);
+            writeLine(`Managed plugin batch: ${error instanceof Error ? error.message : String(error)}; failed.`);
             runStandaloneSkill = false;
             skillOk = false;
         }
@@ -455,7 +488,7 @@ export async function runMearlLifecycle(options, dependencies = {}) {
             if (options.operation === 'uninstall') {
                 if (remainingSkillProfiles.length > 0) {
                     writeLine(`Skill: kept for ${remainingSkillProfiles.join(', ')}.`);
-                    writeLine(`Internal plugins: kept for ${remainingSkillProfiles.join(', ')}.`);
+                    writeLine(`Managed plugins: kept for ${remainingSkillProfiles.join(', ')}.`);
                 }
                 else if (runStandaloneSkill) {
                     skillOk = await runSkill('uninstall', {

package/dist/managedPlugins.d.ts

@@ -0,0 +1,21 @@
+import { findPluginRegistration, readOfficialPluginCatalog } from '@mearl/client/plugin';
+import { installPlugins, uninstallPlugin } from './plugin.js';
+import { runGlobalMearlSkillOperation } from './skills.js';
+import { type CommandRunner } from '@mearl/daemon-core';
+export interface ManagedPluginOptions {
+    env?: NodeJS.ProcessEnv;
+    includeMearlSkill?: boolean;
+    mearlSkillOperation?: 'install' | 'update';
+    runCommand?: CommandRunner;
+    writeLine?: (line: string) => void;
+}
+export interface ManagedPluginDependencies {
+    readCatalog?: typeof readOfficialPluginCatalog;
+    findPluginRegistration?: typeof findPluginRegistration;
+    installPlugins?: typeof installPlugins;
+    uninstallPlugin?: typeof uninstallPlugin;
+    runSkillOperation?: typeof runGlobalMearlSkillOperation;
+}
+/** Only the selected preset's managed registrations participate in lifecycle updates. */
+export declare function installManagedPlugins(options?: ManagedPluginOptions, dependencies?: ManagedPluginDependencies): Promise<'installed' | 'skipped' | 'failed'>;
+export declare function uninstallManagedPlugins(options?: ManagedPluginOptions, dependencies?: ManagedPluginDependencies): Promise<'uninstalled' | 'skipped' | 'failed'>;

package/dist/managedPlugins.js

@@ -0,0 +1,76 @@
+import { findPluginRegistration, readOfficialPluginCatalog, OFFICIAL_PLUGIN_MANAGER } from '@mearl/client/plugin';
+import { installPlugins, uninstallPlugin } from './plugin.js';
+import { runGlobalMearlSkillOperation } from './skills.js';
+import { runCommand } from '@mearl/daemon-core';
+/** Only the selected preset's managed registrations participate in lifecycle updates. */
+export async function installManagedPlugins(options = {}, dependencies = {}) {
+    const writeLine = options.writeLine ?? (line => console.error(line));
+    try {
+        const catalog = (dependencies.readCatalog ?? readOfficialPluginCatalog)();
+        if (!catalog || Object.keys(catalog.plugins).length === 0)
+            return 'skipped';
+        const registrationFor = dependencies.findPluginRegistration ?? findPluginRegistration;
+        const candidates = Object.entries(catalog.plugins).filter(([name]) => {
+            const registration = registrationFor(name);
+            if (registration && registration.managedBy !== OFFICIAL_PLUGIN_MANAGER) {
+                writeLine(`${name} plugin: existing user registration kept.`);
+                return false;
+            }
+            return true;
+        });
+        if (candidates.length === 0)
+            return 'skipped';
+        if (options.includeMearlSkill && !await (dependencies.runSkillOperation ?? runGlobalMearlSkillOperation)(options.mearlSkillOperation ?? 'install', {
+            env: options.env, runCommand: options.runCommand, writeLine, yes: true,
+        }))
+            return 'failed';
+        for (const [name, definition] of candidates) {
+            const code = await (dependencies.installPlugins ?? installPlugins)([...definition.installArgs], options.runCommand ?? runCommand, { registrationManagedBy: OFFICIAL_PLUGIN_MANAGER, env: options.env });
+            if (code !== 0) {
+                writeLine(`${name} plugin: install failed (exit ${code}).`);
+                return 'failed';
+            }
+            if (registrationFor(name)?.managedBy !== OFFICIAL_PLUGIN_MANAGER) {
+                writeLine(`${name} plugin: installation did not create its managed registration.`);
+                return 'failed';
+            }
+            writeLine(`${name} plugin: installed and registered.`);
+        }
+        return 'installed';
+    }
+    catch (error) {
+        writeLine(`Managed plugin batch: ${error instanceof Error ? error.message : String(error)}; failed.`);
+        return 'failed';
+    }
+}
+export async function uninstallManagedPlugins(options = {}, dependencies = {}) {
+    const writeLine = options.writeLine ?? (line => console.error(line));
+    try {
+        const catalog = (dependencies.readCatalog ?? readOfficialPluginCatalog)();
+        if (!catalog)
+            return 'skipped';
+        const registrationFor = dependencies.findPluginRegistration ?? findPluginRegistration;
+        for (const name of Object.keys(catalog.plugins)) {
+            const registration = registrationFor(name);
+            if (!registration)
+                continue;
+            if (registration.managedBy !== OFFICIAL_PLUGIN_MANAGER) {
+                writeLine(`${name} plugin: existing user registration kept.`);
+                continue;
+            }
+            await (dependencies.uninstallPlugin ?? uninstallPlugin)(name, options.runCommand ?? runCommand, { preserveRegistrationsOutsideManager: OFFICIAL_PLUGIN_MANAGER, env: options.env });
+            if (registrationFor(name)) {
+                writeLine(`${name} plugin: uninstall did not clear its registration.`);
+                return 'failed';
+            }
+            writeLine(`${name} plugin: uninstalled.`);
+        }
+        if (options.includeMearlSkill && !await (dependencies.runSkillOperation ?? runGlobalMearlSkillOperation)('uninstall', { env: options.env, runCommand: options.runCommand, writeLine, yes: true }))
+            return 'failed';
+        return 'uninstalled';
+    }
+    catch (error) {
+        writeLine(`Managed plugin batch: ${error instanceof Error ? error.message : String(error)}; failed.`);
+        return 'failed';
+    }
+}

package/dist/npmRegistry.d.ts

@@ -1,3 +1,3 @@
 export declare const OFFICIAL_NPM_REGISTRY = "https://registry.npmjs.org/";
-export declare const ALIBABA_NPM_REGISTRY = "https://registry.anpm.alibaba-inc.com/";
+/** Core packages use their public registry; other scopes retain the caller's configuration. */
 export declare function packageRegistryEnvironment(packageName: string, env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;

package/dist/npmRegistry.js

@@ -1,20 +1,8 @@
 export const OFFICIAL_NPM_REGISTRY = 'https://registry.npmjs.org/';
-export const ALIBABA_NPM_REGISTRY = 'https://registry.anpm.alibaba-inc.com/';
+/** Core packages use their public registry; other scopes retain the caller's configuration. */
 export function packageRegistryEnvironment(packageName, env) {
-    const scope = packageName.split('/')[0];
-    const registry = scope === '@mearl'
-        ? OFFICIAL_NPM_REGISTRY
-        : scope === '@ali'
-            ? ALIBABA_NPM_REGISTRY
-            : undefined;
-    if (!registry)
+    if (packageName.split('/')[0] !== '@mearl')
         return env;
-    // npm-compatible managers and Bun receive the same registry, including scoped npm overrides.
-    return {
-        ...env,
-        npm_config_registry: registry,
-        NPM_CONFIG_REGISTRY: registry,
-        BUN_CONFIG_REGISTRY: registry,
-        [`npm_config_${scope}:registry`]: registry,
-    };
+    return { ...env, npm_config_registry: OFFICIAL_NPM_REGISTRY, NPM_CONFIG_REGISTRY: OFFICIAL_NPM_REGISTRY,
+        BUN_CONFIG_REGISTRY: OFFICIAL_NPM_REGISTRY, 'npm_config_@mearl:registry': OFFICIAL_NPM_REGISTRY };
 }

package/dist/plugin.d.ts

@@ -1,3 +1,5 @@
+import { type PluginCatalogSelection } from '@mearl/client/plugin';
+import { type InstalledSkill } from './skills.js';
 import { type CommandRunner } from '@mearl/daemon-core';
 export interface PluginSetupResult {
     entry: string;
@@ -11,9 +13,17 @@ export interface PluginUninstallResult {
     skillName?: string;
     unregisteredNames: string[];
 }
-export declare function uninstallPlugin(name: string, runner?: CommandRunner): Promise<PluginUninstallResult>;
-/** Ali Skills 的 Installed 区块列出成功路径；计数校验避免输出变化导致漏注册。 */
-export declare function parseInstalledPluginPaths(output: string): string[];
+export declare function uninstallPlugin(name: string, runner?: CommandRunner, options?: {
+    preserveRegistrationsOutsideManager?: string;
+    env?: NodeJS.ProcessEnv;
+}): Promise<PluginUninstallResult>;
+/** Skills 的 Installed 区块列出成功路径；计数校验避免输出变化导致漏注册。 */
+export declare function parseInstalledPluginPaths(output: string, listed?: InstalledSkill[]): string[];
 export declare function installPlugins(args: string[], runner?: CommandRunner, options?: {
     registrationManagedBy?: string;
+    env?: NodeJS.ProcessEnv;
+    selection?: PluginCatalogSelection;
+    expectedSkill?: string;
+    expectedPluginName?: string;
+    confirm?: () => void | Promise<void>;
 }): Promise<number>;