@mearl/setup 3.0.0-beta.8 → 3.0.0

package/dist/browserPreset.js

@@ -1,6 +1,6 @@
 import { invokeLocalHost, listLiveBrowsers } from '@mearl/client/local';
 import { installationOriginCovered, loadInstallationConfig, matchesInstallationOrigin, trustedInstallationPreset } from '@mearl/preset/installation';
-import { createNodePresetLoader, PresetInstaller, resolveInstallationConfigUrl } from './preset.js';
+import { connectedPresetExtensions, createNodePresetLoader, PresetInstaller, resolveInstallationConfigUrl } from './preset.js';
 /** Explicit setup may complete a trusted browser selection before installing any Skills. */
 export async function prepareBrowserSetupPreset(options = {}, dependencies = {}) {
     const env = options.env ?? process.env;
@@ -8,27 +8,29 @@ export async function prepareBrowserSetupPreset(options = {}, dependencies = {})
     const current = await new PresetInstaller({ directory }).store.current();
     if (current.activation || current.receipt)
         return;
-    const now = dependencies.now ?? Date.now;
-    const deadline = now() + (options.waitMs ?? 0);
     const browsers = dependencies.browsers ?? listLiveBrowsers;
     const invoke = dependencies.invoke ?? invokeLocalHost;
-    const sleep = dependencies.sleep ?? (ms => new Promise(resolve => setTimeout(resolve, ms)));
     const configuration = dependencies.configuration ?? (() => {
         const url = resolveInstallationConfigUrl(env.MEARL_INSTALLATION_CONFIG_URL);
         return loadInstallationConfig(url, url.origin, AbortSignal.timeout(5_000));
     });
-    const read = async (timeoutSec = 5) => {
-        const targets = browsers().filter(browser => !browser.provider && browser.transport === 'extension' && (browser.status === undefined || browser.status === 'connected') && (!env.MEARL_SOCKET_PATH || browser.socketPath === env.MEARL_SOCKET_PATH));
+    const connected = () => connectedPresetExtensions(browsers(), env.MEARL_SOCKET_PATH?.trim());
+    const read = async () => {
+        const targets = connected();
         if (!targets.length)
             return;
         return (await Promise.all(targets.map(async (browser) => {
             let value;
             try {
-                value = await invoke('preset_browser_status', {}, { socketPath: browser.socketPath, timeoutSec });
+                value = await invoke('preset_browser_status', {}, { socketPath: browser.socketPath, timeoutSec: 5 });
             }
             catch {
+                if (!connected().some(target => target.browserId === browser.browserId && target.socketPath === browser.socketPath))
+                    return [];
                 throw new Error(`Cannot read preset from ${browser.browserId}. Reconnect the extension and retry setup, or use --preset <source>.`);
             }
+            if (value?.error === 'EXTENSION_NOT_CONNECTED')
+                return [];
             if (value?.error || typeof value?.browserReady !== 'boolean' || !Object.hasOwn(value, 'browserRevision') || (value.presetId !== undefined && (typeof value.presetId !== 'string' || !value.presetId || typeof value.presetSource !== 'string' || typeof value.browserRevision !== 'string' || value.browserReady !== true)))
                 throw new Error(`Browser preset is unavailable in ${browser.browserId}. Reconnect the extension and retry setup, or use --preset <source>.`);
             if (!value.presetId)
@@ -36,21 +38,9 @@ export async function prepareBrowserSetupPreset(options = {}, dependencies = {})
             return [{ browserId: browser.browserId, presetId: value.presetId, presetSource: value.presetSource, browserRevision: value.browserRevision }];
         }))).flat();
     };
-    let selected = await read();
-    if (!selected && now() < deadline)
-        options.writeLine?.('Waiting for the Mearl extension to connect and checking its installed preset…');
-    while (!selected && now() < deadline) {
-        await sleep(Math.min(1000, deadline - now()));
-        if (now() < deadline)
-            selected = await read(Math.max(0.1, Math.min(5, (deadline - now()) / 1000)));
-    }
-    if (!selected) {
-        options.writeLine?.('No connected Mearl extension was found. Continuing without a browser preset; connect and rerun setup to adopt it, or use --preset <source> to select a preset.');
-        return;
-    }
-    if (!selected.length)
+    const accepted = await read();
+    if (!accepted?.length)
         return;
-    const accepted = selected;
     const first = accepted[0];
     if (accepted.some(value => value.presetId !== first.presetId || value.presetSource !== first.presetSource))
         throw new Error('Connected browsers use different presets. Select one explicitly with --preset <source>.');
@@ -58,7 +48,7 @@ export async function prepareBrowserSetupPreset(options = {}, dependencies = {})
     if (!trusted)
         throw new Error('The browser preset is not in the trusted installation catalog. Install it explicitly with --preset <source>.');
     const load = dependencies.load ?? createNodePresetLoader();
-    const installer = new PresetInstaller({ directory, load: (source, resourceOptions) => {
+    const installer = new PresetInstaller({ directory, connectedExtensionsOnly: true, load: (source, resourceOptions) => {
             const url = new URL(source);
             if (url.protocol !== 'https:' || url.username || url.password || !trusted.origins.some(origin => matchesInstallationOrigin(origin, url)))
                 throw new Error('Browser preset resource is outside the trusted installation catalog');

package/dist/cli.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { installMearlBrowserExtension } from './browserExtension.js';
+import { downloadMearlBrowserExtension, installMearlBrowserExtension } from './browserExtension.js';
 import { runMearlLifecycle, type MearlLifecycleOperation } from './lifecycle.js';
 import type { MearlProfile } from './profiles.js';
 import { ensureOfficialPlugin, installPlugins, setupPlugin, uninstallPlugin } from './plugin.js';
@@ -9,10 +9,13 @@ import { prepareSetupPreset } from './setupPreset.js';
 export { SETUP_VERSION } from './setupVersion.js';
 interface ParsedArgs {
     cloudMode?: string;
+    extract?: boolean;
     force?: boolean;
     full?: boolean;
     help: boolean;
-    operation?: MearlLifecycleOperation | 'extension' | 'plugin' | 'provider' | 'preset';
+    operation?: MearlLifecycleOperation | 'extension' | 'plugin' | 'provider' | 'preset' | 'profile';
+    profileSource?: string;
+    profileBrowser?: string;
     presetCommand?: 'apply' | 'update' | 'status' | 'repair';
     presetSource?: string;
     presetReplaceSkills?: string[];
@@ -30,12 +33,14 @@ interface ParsedArgs {
     yes: boolean;
 }
 export interface SetupCliDependencies {
+    installProfile?: typeof installProfile;
     preparePreset?: typeof prepareSetupPreset;
     runPreset?: typeof runPresetCommand;
     registerPlugin?: typeof setupPlugin;
     ensureOfficialPlugin?: typeof ensureOfficialPlugin;
     installPlugins?: typeof installPlugins;
     uninstallPlugin?: typeof uninstallPlugin;
+    downloadBrowserExtension?: typeof downloadMearlBrowserExtension;
     installBrowserExtension?: typeof installMearlBrowserExtension;
     installProvider?: typeof installProviderPackage;
     runLifecycle?: typeof runMearlLifecycle;
@@ -43,4 +48,5 @@ export interface SetupCliDependencies {
     updateProvider?: typeof updateProviderPackage;
 }
 export declare function parseSetupArgs(argv: string[]): ParsedArgs;
+declare function installProfile(source: string, browser?: string): Promise<unknown>;
 export declare function main(argv?: string[], interactiveTerminal?: boolean, dependencies?: SetupCliDependencies): Promise<number>;

package/dist/cli.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import { Command, CommanderError } from 'commander';
-import { installMearlBrowserExtension, isUnsupportedCdpMethodError } from './browserExtension.js';
+import { invoke, listLiveBrowsers } from '@mearl/client/local';
+import { parseProfileSource } from '@mearl/preset/bundles';
+import { downloadMearlBrowserExtension, installMearlBrowserExtension, isUnsupportedCdpMethodError } from './browserExtension.js';
 import { runMearlLifecycle } from './lifecycle.js';
 import { isMearlReleaseLine } from './version.js';
 import { ensureOfficialPlugin, installPlugins, setupPlugin, uninstallPlugin } from './plugin.js';
@@ -25,6 +27,15 @@ function commanderError(error) {
     return new Error(message);
 }
 export function parseSetupArgs(argv) {
+    if (argv[0] === 'profile') {
+        if (argv.length === 2 && (argv[1] === '--help' || argv[1] === '-h'))
+            return { ...baseParsedArgs(), help: true };
+        if (argv[1] !== 'install' || !argv[2] || (argv.length !== 3 && !(argv.length === 5 && argv[3] === '--browser' && argv[4]))) {
+            throw new Error('profile requires install <GitHub owner/repo[@ref] or HTTPS bundle URL> [--browser <id-or-name>]');
+        }
+        parseProfileSource(argv[2]);
+        return { ...baseParsedArgs(), operation: 'profile', profileSource: argv[2], profileBrowser: argv[4] };
+    }
     if (argv[0] === 'preset') {
         if (argv[1] === 'repair') {
             const command = new Command('preset repair')
@@ -163,12 +174,17 @@ export function parseSetupArgs(argv) {
         .configureOutput({ writeErr: () => { }, writeOut: () => { } })
         .option('--full')
         .option('--force')
+        .option('--extract')
         .option('-y, --yes')
         .option('--non-interactive')
         .action(() => {
         const options = extension.opts();
+        if (options.extract && (options.full || options.force)) {
+            throw new Error('--extract cannot be combined with --full or --force');
+        }
         parsed = {
             ...baseParsedArgs(),
+            ...(options.extract ? { extract: true } : {}),
             ...(options.force ? { force: true } : {}),
             ...(options.full ? { full: true } : {}),
             operation: 'extension',
@@ -206,6 +222,7 @@ Environment commands:
   uninstall [options]             Uninstall detected or selected environments
 
 Integration commands:
+  profile install <source>       Install one App profile bundle in a connected extension
   preset apply <source>          Apply a preset, synchronize hosts and install declared components
   preset update                  Update the selected preset, preserving user overrides
   preset repair                  Retry the installed preset using its accepted resources
@@ -219,6 +236,7 @@ Integration commands:
 
 Browser extension:
   extension [--full] [--force]    Install or update the browser extension
+  extension --extract            Download and unpack the extension for manual loading
 
 Environment options:
   --local                         Manage @mearl/native-host and @mearl/client
@@ -251,8 +269,8 @@ Examples:
   npx @mearl/setup --local --cloud
   npx @mearl/setup update
   npx @mearl/setup uninstall --full
-  npx @mearl/setup plugin uninstall yuque
-  npx @mearl/setup provider install @example/mearl-provider-brow
+  npx @mearl/setup plugin uninstall tabs
+  npx @mearl/setup provider install @example/mearl-provider-device
   npx @mearl/setup preset repair --replace-skill example-skill
   npx @mearl/setup extension --full`;
     console.log(output.replaceAll('npx @mearl/setup', SETUP_COMMAND));
@@ -274,9 +292,22 @@ async function runSetupLifecycle(options, dependencies) {
     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));
+    const warnings = [...new Set([...(preset.warnings ?? []), ...(actual.warnings ?? [])])];
+    console.log(JSON.stringify({ ...actual, warnings }, null, 2));
     return actual.ready ? 0 : 3;
 }
+async function installProfile(source, browser) {
+    if (!browser) {
+        const extensions = listLiveBrowsers().filter(target => target.transport === 'extension' && (target.status === undefined || target.status === 'connected'));
+        if (extensions.length !== 1)
+            throw new Error(extensions.length
+                ? 'Multiple extensions are connected. Select one with --browser <id-or-name>.'
+                : 'Connect a Mearl extension before installing App profiles.');
+        browser = extensions[0].browserId;
+    }
+    console.error('If the bundle source needs permission, confirm it in the browser.');
+    return invoke('profile_install', { source }, { browser, timeoutSec: 150 });
+}
 export async function main(argv = process.argv.slice(2), interactiveTerminal = process.stdin.isTTY === true && process.stdout.isTTY === true, dependencies = {}) {
     let parsed;
     try {
@@ -295,6 +326,17 @@ export async function main(argv = process.argv.slice(2), interactiveTerminal = p
         console.log(SETUP_VERSION);
         return 0;
     }
+    if (parsed.operation === 'profile') {
+        try {
+            const result = await (dependencies.installProfile ?? installProfile)(parsed.profileSource, parsed.profileBrowser);
+            console.log(JSON.stringify(result, null, 2));
+            return 0;
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            return 1;
+        }
+    }
     if (parsed.operation === 'preset') {
         try {
             const run = dependencies.runPreset ?? runPresetCommand;
@@ -376,6 +418,18 @@ export async function main(argv = process.argv.slice(2), interactiveTerminal = p
         }
     }
     if (parsed.operation === 'extension') {
+        if (parsed.extract) {
+            try {
+                const result = await (dependencies.downloadBrowserExtension ?? downloadMearlBrowserExtension)();
+                console.log(`Mearl v${result.version} is ready to load from ${result.path}`);
+                console.log('Open chrome://extensions/, enable Developer mode, click Load unpacked, and select that directory.');
+                return 0;
+            }
+            catch (error) {
+                console.error(error instanceof Error ? error.message : String(error));
+                return 1;
+            }
+        }
         if (!interactiveTerminal && !parsed.yes) {
             console.error('Non-interactive input detected. Re-run with --yes or --non-interactive.');
             return 2;
@@ -411,6 +465,7 @@ export async function main(argv = process.argv.slice(2), interactiveTerminal = p
                     : `Browser extension v${result.version} was not installed.`);
                 if (result.cdpError) {
                     console.error(`CDP installation failed: ${result.cdpError}`);
+                    console.error(`To load the extension manually, run: ${SETUP_COMMAND} extension --extract`);
                     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: ${SETUP_COMMAND} extension`);
                         extensionFailureIsTerminal = true;

package/dist/lifecycle.d.ts

@@ -5,6 +5,8 @@ import { detectGlobalPackage, type PackageManagerInstallation, type PackageDetec
 import { type DetectedMearlProfiles, type MearlProfile } from './profiles.js';
 import { uninstallNativeHostArtifacts } from './nativeHost.js';
 import { type CommandRunner } from '@mearl/daemon-core';
+import { readInstallationManagement } from '@mearl/daemon-core/installation';
+import { claimPresetInstallation } from './presetInstallationLease.js';
 import { installManagedPlugins, uninstallManagedPlugins } from './managedPlugins.js';
 import { uninstallPlugin } from './plugin.js';
 import { uninstallProviderPackage } from './provider.js';
@@ -30,6 +32,8 @@ export interface MearlLifecycleOptions {
     env?: NodeJS.ProcessEnv;
 }
 export interface MearlLifecycleDependencies {
+    readManagement?: typeof readInstallationManagement;
+    claimLifecycle?: () => ReturnType<typeof claimPresetInstallation>;
     prepareBrowserPreset?: typeof prepareBrowserSetupPreset;
     preparePreset?: typeof prepareSetupPreset;
     onPresetStatus?: (status: PresetInstallStatus) => void;

package/dist/lifecycle.js

@@ -1,6 +1,7 @@
 import { SETUP_VERSION } from './setupVersion.js';
 import fs from 'node:fs';
 import path from 'node:path';
+import { homedir } from 'node:os';
 import { createInterface } from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
 import { listPluginNames } from '@mearl/client/plugin';
@@ -9,7 +10,9 @@ 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 { executableNames, prependCommandPath, runCommand, withOwnedCommands, } from '@mearl/daemon-core';
+import { readInstallationManagement, setupManagementCommand, setupRuntimeCompatible } from '@mearl/daemon-core/installation';
+import { claimPresetInstallation } from './presetInstallationLease.js';
 import { isMearlReleaseLine, mearlPackageSelector } from './version.js';
 import { installManagedPlugins, uninstallManagedPlugins, } from './managedPlugins.js';
 import { uninstallPlugin } from './plugin.js';
@@ -176,6 +179,38 @@ export async function runMearlLifecycle(options, dependencies = {}) {
     if (options.targetLine && !isMearlReleaseLine(options.targetLine)) {
         throw new Error('targetLine must be a valid Mearl release line such as 2.3.x');
     }
+    const writeLine = dependencies.writeLine ?? (line => console.error(line));
+    let lease;
+    try {
+        lease = (dependencies.claimLifecycle ?? (() => claimPresetInstallation(path.join(homedir(), '.agents', '.mearl-setup-lifecycle.json'))))();
+        const readManagement = () => (dependencies.readManagement ?? readInstallationManagement)({ directory: (options.env ?? process.env).MEARL_CAPABILITY_DIR });
+        let acceptedRevision = (await readManagement()).revision;
+        let selector = mearlPackageSelector(SETUP_VERSION, options.targetLine);
+        const assertManagement = async (expected = acceptedRevision) => {
+            const { setup, revision } = await readManagement();
+            if (revision !== expected)
+                throw new Error('PRESET_SELECTION_CHANGED: The selected preset changed during setup.');
+            if (setup && options.operation !== 'uninstall' && !setupRuntimeCompatible(setup, SETUP_VERSION, options.targetLine)) {
+                throw new Error(`SETUP_RUNTIME_CONFLICT: The selected preset requires ${setup.runtime}. Use ${setupManagementCommand(setup)} ${options.operation}.`);
+            }
+            selector = setup?.runtime ? options.targetLine ?? SETUP_VERSION : mearlPackageSelector(SETUP_VERSION, options.targetLine);
+        };
+        await assertManagement();
+        const runner = dependencies.runCommand ?? runCommand;
+        return await withOwnedCommands(lease.lifecycle, () => executeLifecycle(options, {
+            ...dependencies,
+            runCommand: async (...args) => { await assertManagement(); return runner(...args); },
+        }, async (revision) => { await assertManagement(revision); acceptedRevision = revision; }, () => selector));
+    }
+    catch (error) {
+        writeLine(`Setup: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+    finally {
+        lease?.release();
+    }
+}
+async function executeLifecycle(options, dependencies, acceptPreset, packageSelector) {
     const env = options.env ?? process.env;
     const writeLine = dependencies.writeLine ?? (line => console.error(line));
     const existsSync = dependencies.existsSync ?? fs.existsSync;
@@ -290,6 +325,8 @@ export async function runMearlLifecycle(options, dependencies = {}) {
             stagedPreset = await (dependencies.preparePreset ?? prepareSetupPreset)({
                 source: options.presetSource, env,
             });
+            if (stagedPreset)
+                await acceptPreset(stagedPreset.revision);
         }
         catch (error) {
             writeLine(`Preset preparation: ${error instanceof Error ? error.message : String(error)}`);
@@ -322,7 +359,7 @@ export async function runMearlLifecycle(options, dependencies = {}) {
             detected.get('local') ??
             detected.get('cloud') ??
             resolveInvokingManager(env);
-        const sharedClient = await runPackageOperation(clientInstallation, options.operation, [UNIFIED_CLIENT], mearlPackageSelector(SETUP_VERSION, options.targetLine), runner, env, 'Packages (shared client)', writeLine);
+        const sharedClient = await runPackageOperation(clientInstallation, options.operation, [UNIFIED_CLIENT], packageSelector(), runner, env, 'Packages (shared client)', writeLine);
         if (!sharedClient.ok) {
             writeLine('Mearl setup incomplete. Review the messages above.');
             return false;
@@ -362,7 +399,7 @@ export async function runMearlLifecycle(options, dependencies = {}) {
         if (packages.length === 0) {
             continue;
         }
-        const packageResult = await runPackageOperation(installation, packageOperation, packages, mearlPackageSelector(SETUP_VERSION, options.targetLine), runner, env, `Packages (${profile})`, writeLine);
+        const packageResult = await runPackageOperation(installation, packageOperation, packages, packageSelector(), runner, env, `Packages (${profile})`, writeLine);
         if (!packageResult.ok) {
             packagesOk = false;
             continue;
@@ -422,7 +459,9 @@ export async function runMearlLifecycle(options, dependencies = {}) {
     }
     if (packagesOk && selectsInitialPreset && !stagedPreset && !options.presetSource && lifecycleSelected.some(profile => profile === 'local' || profile === 'mcp')) {
         try {
-            stagedPreset = await (dependencies.prepareBrowserPreset ?? prepareBrowserSetupPreset)({ env, waitMs: 65_000, writeLine });
+            stagedPreset = await (dependencies.prepareBrowserPreset ?? prepareBrowserSetupPreset)({ env, writeLine });
+            if (stagedPreset)
+                await acceptPreset(stagedPreset.revision);
         }
         catch (error) {
             writeLine(`Browser preset: ${error instanceof Error ? error.message : String(error)}`);
@@ -432,6 +471,8 @@ export async function runMearlLifecycle(options, dependencies = {}) {
     if (packagesOk && selectsInitialPreset && !stagedPreset && options.defaultPresetSource) {
         try {
             stagedPreset = await (dependencies.preparePreset ?? prepareSetupPreset)({ fallbackSource: options.defaultPresetSource, env });
+            if (stagedPreset)
+                await acceptPreset(stagedPreset.revision);
         }
         catch (error) {
             writeLine(`Default preset: ${error instanceof Error ? error.message : String(error)}`);

package/dist/plugin.d.ts

@@ -5,7 +5,7 @@ export interface PluginSetupResult {
     entry: string;
     name: string;
 }
-export declare function setupPlugin(target: string, requestedName?: string): Promise<PluginSetupResult>;
+export declare function setupPlugin(target: string, requestedName?: string, runner?: CommandRunner): Promise<PluginSetupResult>;
 export declare function ensureOfficialPlugin(name: string, runner?: CommandRunner): Promise<'existing' | 'installed'>;
 export interface PluginUninstallResult {
     entryMissing?: boolean;

package/dist/plugin.js

@@ -30,14 +30,15 @@ function defaultPluginName(target, entry) {
         ? basename(dirname(entryDirectory))
         : basename(entryDirectory);
 }
-export async function setupPlugin(target, requestedName) {
+export async function setupPlugin(target, requestedName, runner = runCommand) {
     if (requestedName)
         assertPluginName(requestedName);
     const entry = resolvePluginEntry(target);
     const plugin = await loadPlugin(entry, registrationContext);
     const name = requestedName || plugin.name || defaultPluginName(target, entry);
     assertPluginName(name);
-    await ensurePluginRuntime();
+    await ensurePluginRuntime(runner);
+    await plugin.setup?.({ runCommand: runner });
     return {
         entry: registerPlugin(name, entry, plugin.description, {
             hasPublicCommands: Boolean(plugin.commandHelp(name)),
@@ -345,6 +346,7 @@ export async function installPlugins(args, runner = runCommand, options = {}) {
             throw new Error(`多个 skill 使用插件名称 ${name}，请调整入口的 name metadata。`);
         plugins.set(name, {
             entry,
+            setup: plugin.setup,
             hasPublicCommands: Boolean(plugin.commandHelp(name)),
             description: plugin.description,
             ...(plugin.toolbox ? { toolbox: plugin.toolbox } : {}),
@@ -357,14 +359,26 @@ export async function installPlugins(args, runner = runCommand, options = {}) {
         return 0;
     }
     await ensurePluginRuntime(runner);
-    for (const [name, { entry, description, toolbox, appProfiles, profileSources, hasPublicCommands },] of plugins) {
+    for (const [name, { entry, description, toolbox, appProfiles, profileSources, hasPublicCommands, setup },] of plugins) {
         await options.confirm?.();
         verifySkill();
-        const existing = findPluginRegistration(name);
-        if (options.registrationManagedBy && existing && existing.managedBy !== options.registrationManagedBy) {
+        const hasUserRegistration = () => {
+            const existing = findPluginRegistration(name);
+            return options.registrationManagedBy && existing && existing.managedBy !== options.registrationManagedBy;
+        };
+        if (hasUserRegistration()) {
             console.error(`Plugin ${name}: existing user registration kept.`);
             continue;
         }
+        if (setup) {
+            await setup({ runCommand: runner });
+            await options.confirm?.();
+            verifySkill();
+            if (hasUserRegistration()) {
+                console.error(`Plugin ${name}: existing user registration kept.`);
+                continue;
+            }
+        }
         registerPlugin(name, entry, description, {
             hasPublicCommands,
             managedBy: options.registrationManagedBy ?? (cli.id === 'skills' ? undefined : cli.id),

package/dist/preset.d.ts

@@ -1,4 +1,4 @@
-import { invoke } from '@mearl/client/local';
+import { invoke, listLiveBrowsers } from '@mearl/client/local';
 import { type JsonObject } from '@mearl/preset';
 import { type BundleLoader, type PreparedPreset } from '@mearl/preset/bundles';
 import { PresetInstallationStore } from './presetStore.js';
@@ -60,6 +60,8 @@ export interface PresetInstallerOptions {
     load?: BundleLoader;
     hosts?: () => PresetHostTarget[];
     invoke?: typeof invoke;
+    /** CLI setup synchronizes connected extensions without requiring their acknowledgement. */
+    connectedExtensionsOnly?: boolean;
 }
 export interface PresetApplyOptions {
     validatePrepared?: (prepared: PreparedPreset) => Promise<void>;
@@ -76,6 +78,7 @@ export interface StagedPresetInstallation {
 }
 /** The caller chooses the source; this loader adds no identity or credential discovery. */
 export declare function createNodePresetLoader(): BundleLoader;
+export declare function connectedPresetExtensions(browsers: ReturnType<typeof listLiveBrowsers>, socketPath?: string): import("@mearl/client/local").LiveBrowser[];
 /** Installation and live acknowledgements are distinct; browser/external installs remain pending. */
 export declare class PresetInstaller {
     readonly store: PresetInstallationStore;

package/dist/preset.js

@@ -71,6 +71,10 @@ function localHosts(allowStart = false) {
     const hosts = configured ? [{ id: 'local', socketPath: configured }] : listLiveBrowsers().filter(browser => !browser.provider).map(browser => ({ id: browser.browserId, socketPath: browser.socketPath }));
     return hosts.length ? Array.from(new Map(hosts.map(host => [host.socketPath, host])).values()) : [{ id: 'local', ...(allowStart ? {} : { socketPath: SOCKET_PATH }) }];
 }
+export function connectedPresetExtensions(browsers, socketPath) {
+    return browsers.filter(browser => !browser.provider && browser.transport === 'extension' &&
+        (browser.status === undefined || browser.status === 'connected') && (!socketPath || browser.socketPath === socketPath));
+}
 /** Installation and live acknowledgements are distinct; browser/external installs remain pending. */
 export class PresetInstaller {
     store;
@@ -99,13 +103,18 @@ export class PresetInstaller {
         }));
     }
     async browserStatus(reload, browserRevision, installationRevision) {
-        const targets = this.options.hosts?.() ?? localHosts(reload);
+        const targets = this.options.connectedExtensionsOnly
+            ? connectedPresetExtensions(listLiveBrowsers(), process.env.MEARL_SOCKET_PATH?.trim()).map(browser => ({ id: browser.browserId, socketPath: browser.socketPath }))
+            : this.options.hosts?.() ?? localHosts(reload);
         return Promise.all(targets.map(async (target) => {
             try {
                 const result = await this.invokeHost(reload ? 'preset_browser_sync' : 'preset_browser_status', reload ? { installationRevision } : {}, target, reload ? 130 : 15, reload);
                 if (result?.accepted === false)
                     return { id: target.id, state: 'rejected', settingsReady: false, error: typeof result.error === 'string' ? result.error : 'Browser preset activation rejected' };
-                return { id: target.id, state: result?.ready === true && result?.browserRevision === browserRevision && result?.installationRevision === installationRevision ? 'active' : 'pending', settingsReady: result?.settingsReady === true, ...(Array.isArray(result?.permissionPending) && result.permissionPending.length ? { error: 'PRESET_DOMAIN_PERMISSION_REQUIRED: Open extension settings and authorize preset domains' } : {}) };
+                const error = Array.isArray(result?.permissionPending) && result.permissionPending.length
+                    ? 'PRESET_DOMAIN_PERMISSION_REQUIRED: Open extension settings and authorize preset domains'
+                    : typeof result?.error === 'string' ? result.error : undefined;
+                return { id: target.id, state: result?.ready === true && result?.browserRevision === browserRevision && result?.installationRevision === installationRevision ? 'active' : 'pending', settingsReady: result?.settingsReady === true, ...(error ? { error } : {}) };
             }
             catch {
                 return { id: target.id, state: 'pending', settingsReady: false, error: 'BROWSER_UNAVAILABLE' };
@@ -150,7 +159,8 @@ export class PresetInstaller {
         result.settings = mergePresetDefaults(preset.defaults, receipt.overrides);
         result.nodeRevision = receipt.nodeRevision;
         result.browserRevision = receipt.browserRevision;
-        result.browserSyncRequired = receipt.browserSyncRequired === true;
+        const browserSyncRequired = receipt.browserSyncRequired === true && !this.options.connectedExtensionsOnly;
+        result.browserSyncRequired = browserSyncRequired;
         result.localComponentCount = Object.values(preset.packages).filter(entry => entry.enabled !== false && entry.targets?.includes('node')).length
             + [...Object.values(preset.skills), ...Object.values(preset.providers)].filter(entry => entry.enabled !== false).length;
         result.hosts = await this.hostStatus(false, receipt.nodeRevision, receipt.revision);
@@ -163,7 +173,7 @@ export class PresetInstaller {
                 continue;
             for (const runtime of entry.targets ?? []) {
                 if (runtime === 'browser') {
-                    if (!browserReady)
+                    if (browserSyncRequired && !browserReady)
                         result.pending.push({ kind: 'packages', id, runtime, reason: 'BROWSER_SYNC_REQUIRED' });
                 }
                 else if (!receipt.managedModules.includes(id) && Object.keys(current.prepared.bundles.find(bundle => bundle.manifest.id === id)?.manifest.contributions?.nodeRuntimes ?? {}).length)
@@ -189,9 +199,9 @@ export class PresetInstaller {
             }
         if (receipt.nodeSyncRequired && !nodeReady && !result.pending.some(entry => entry.reason === 'HOST_SYNC_REQUIRED'))
             result.pending.push({ kind: 'preset', id: preset.id, runtime: 'node', reason: 'HOST_SYNC_REQUIRED' });
-        if (receipt.browserSyncRequired && !browserReady && !result.pending.some(entry => entry.reason === 'BROWSER_SYNC_REQUIRED'))
+        if (browserSyncRequired && !browserReady && !result.pending.some(entry => entry.reason === 'BROWSER_SYNC_REQUIRED'))
             result.pending.push({ kind: 'preset', id: preset.id, runtime: 'browser', reason: 'BROWSER_SYNC_REQUIRED' });
-        if (receipt.browserSyncRequired && browserReady && Object.keys(result.settings ?? {}).length && !result.browsers.every(host => host.settingsReady))
+        if (browserSyncRequired && browserReady && Object.keys(result.settings ?? {}).length && !result.browsers.every(host => host.settingsReady))
             result.pending.push({ kind: 'preset', id: preset.id, runtime: 'browser', reason: 'SETTINGS_APPLY_REQUIRED' });
         result.ready = result.pending.length === 0;
         return result;
@@ -207,18 +217,18 @@ export class PresetInstaller {
             await this.hostStatus(true, previous.activation?.revision ?? '', previous.activation?.installationRevision ?? '');
             throw new Error(`Node activation rejected; previous selection restored: ${rejection.error}`);
         }
-        if (receipt.browserSyncRequired) {
-            const browsers = await this.browserStatus(true, receipt.browserRevision, receipt.revision);
-            const rejected = browsers.find(host => host.state === 'rejected');
-            if (rejected)
-                throw new Error(`Browser activation rejected; installed selection retained for retry: ${rejected.error}`);
-        }
+        const browsers = receipt.browserSyncRequired ? await this.browserStatus(true, receipt.browserRevision, receipt.revision) : [];
+        const rejected = browsers.find(host => host.state === 'rejected');
+        if (rejected && !this.options.connectedExtensionsOnly)
+            throw new Error(`Browser activation rejected; installed selection retained for retry: ${rejected.error}`);
         const installed = await this.store.current({ verifyResources: false });
         if (installed.receipt?.revision !== receipt.revision || !installed.preset)
             throw new BundleError('BUNDLE_CONFLICT', 'The selected preset changed before component installation');
         const hasExternal = [...Object.values(installed.preset.skills), ...Object.values(installed.preset.providers)].some(entry => entry.enabled !== false);
         const components = hasExternal || installed.activation?.bindings['plugins.catalog'] ? await this.componentStatus(true, receipt, replaceSkills) : {};
         const status = await this.status();
+        if (rejected)
+            status.warnings.push(`Browser preset activation rejected by ${rejected.id}: ${rejected.error}`);
         if (components.error)
             status.warnings.push(`Component installation failed; completed assets retained for retry: ${components.error}`);
         if (status.revision !== receipt.revision)
@@ -305,7 +315,7 @@ export class PresetInstaller {
 export async function runPresetCommand(command, source, options = {}) {
     if (command !== 'repair' && options.replaceSkills !== undefined)
         throw new Error('Skill replacements require preset repair');
-    const installer = new PresetInstaller();
+    const installer = new PresetInstaller({ connectedExtensionsOnly: true });
     if (command === 'repair')
         return installer.repair(options);
     return command === 'status' ? installer.status() : command === 'update' ? installer.update() : installer.apply(source);

package/dist/presetStore.d.ts

@@ -1,46 +1,2 @@
-import { type JsonObject, type CapabilityActivation, type ResolvedPreset } from '@mearl/preset';
-import { type PreparedBundle, type PreparedPreset, type PresetSnapshot } from '@mearl/preset/bundles';
-export interface PresetInstallReceipt {
-    schemaVersion: 1;
-    snapshot: PresetSnapshot;
-    bundles: Array<Omit<PreparedBundle, 'resources'>>;
-    browserRevision: string;
-    nodeRevision: string;
-    managedModules: string[];
-    nodeSyncRequired: boolean;
-    browserSyncRequired?: boolean;
-    overrides: JsonObject;
-    revision: string;
-}
-interface SelectionState {
-    rawHash: string | null;
-    activation?: CapabilityActivation;
-    receipt?: PresetInstallReceipt;
-    prepared?: PreparedPreset;
-    preset?: ResolvedPreset;
-}
-/** One pointer binds the desired preset, user overrides and exact Node selection. */
-export declare class PresetInstallationStore {
-    readonly directory: string;
-    readonly mearlApiVersion: string;
-    private readonly pointer;
-    constructor(options?: {
-        directory?: string;
-        mearlApiVersion?: string;
-    });
-    private assertCurrent;
-    current(options?: {
-        verifyResources?: boolean;
-    }): Promise<SelectionState>;
-    apply(input: Pick<PreparedPreset, 'snapshot' | 'bundles'>, options: {
-        expectedRevision: string | null;
-        overrides?: JsonObject;
-        signal?: AbortSignal;
-        confirm?: () => Promise<void>;
-    }): Promise<PresetInstallReceipt>;
-    rollback(expectedRevision: string): Promise<void>;
-    collectGarbage(): Promise<void>;
-    private collectLocked;
-}
-export declare function presetSelectionRevision(state: SelectionState): string | null;
-export {};
+export { PresetInstallationStore, presetSelectionRevision } from '@mearl/daemon-core/installation';
+export type { PresetInstallReceipt } from '@mearl/daemon-core/installation';