@mearl/setup 2.2.2

package/README.md

@@ -0,0 +1,52 @@
+# @mearl/setup
+
+Mearl 环境的一次性安装、更新与卸载工具。无需先全局安装 setup：
+
+```bash
+npx @mearl/setup <install|update|uninstall> [--local|--cloud|--mcp] [--yes]
+```
+
+## 行为
+
+- `install` 未指定环境时默认 `--local`。
+- `update` 和 `uninstall` 未指定环境时，从当前 `PATH` 中的
+  `mearl-native-host`、`mearl-cloud`、`mearl-mcp-server` 自动检测，可同时处理
+  多个已安装环境。
+- 显式传入 `--local`、`--cloud` 或 `--mcp` 时只处理指定环境。
+- 已有环境沿用其原包管理器和全局安装前缀；首次安装沿用启动 setup 的包管理器。
+- local/cloud 共用的全局 mearl skill 通过 `ali-skills` 的 JSON 清单定位，只处理一次。
+- 卸载一个环境但另一个仍依赖全局 mearl skill 时会保留 skill。
+- `--mcp` 的客户端配置和清理由 `@mearl/mcp-server` 自己的命令完成。
+
+## 人工与 Agent 使用
+
+- 人工在终端执行时不加 `--yes`，需要选择 Skill 安装目标或 MCP 客户端时会显示交互提示。
+- Agent、CI 或其他无 TTY 环境应加 `--yes`（也可写
+  `--non-interactive`）。首次安装会选择已检测到的 Agent / MCP 客户端，卸载会清理
+  所有已检测到的相关配置。
+- 无 TTY 环境执行 `install` 或 `uninstall` 却未加上述参数时，会在任何改动前退出并提示正确命令。
+- 退出码 `0` 表示完整成功，`1` 表示执行未完成，`2` 表示参数或交互模式不适用。
+
+## 示例
+
+```bash
+# 默认安装本地浏览器环境
+npx @mearl/setup install
+
+# Agent / CI 无交互安装
+npx @mearl/setup install --yes
+
+# 安装云端 Agent 环境
+npx @mearl/setup install --cloud
+
+# 自动更新当前 PATH 中检测到的全部 Mearl 环境
+npx @mearl/setup update
+
+# 只卸载本地环境
+npx @mearl/setup uninstall --local
+
+# 自动检测并无交互卸载
+npx @mearl/setup uninstall --yes
+```
+
+原有的 npm/npx 安装方式和各包 CLI 保持可用；setup 只是统一的便利入口。

package/dist/aliSkills.d.ts

@@ -0,0 +1,32 @@
+import fs from 'node:fs';
+import { type CommandRunner } from './process.js';
+export interface AliSkillsCliOutput {
+    stdout: string;
+    stderr: string;
+}
+export type AliSkillsCliRunner = (executable: string, args: string[], cwd?: string) => Promise<AliSkillsCliOutput>;
+export interface ResolveAliSkillsOptions {
+    env?: NodeJS.ProcessEnv;
+    existsSync?: (filePath: string) => boolean;
+    homedir?: () => string;
+    platform?: NodeJS.Platform;
+    processExecPath?: string;
+    readdirSync?: typeof fs.readdirSync;
+}
+export declare function stripAnsi(value: string): string;
+export declare function resolveAliSkillsExecutable(options?: ResolveAliSkillsOptions): string | null;
+export declare const runAliSkillsCli: AliSkillsCliRunner;
+interface AliSkillsInvocation {
+    command: string;
+    argsPrefix: string[];
+    env: NodeJS.ProcessEnv;
+}
+export declare function resolveAliSkillsInvocation(options?: ResolveAliSkillsOptions): AliSkillsInvocation | null;
+export declare function parseGlobalMearlSkillPaths(output: string): string[];
+export type MearlSkillOperation = 'install' | 'update' | 'uninstall';
+export declare function runGlobalMearlSkillOperation(operation: MearlSkillOperation, options?: ResolveAliSkillsOptions & {
+    runCommand?: CommandRunner;
+    yes?: boolean;
+    writeLine?: (line: string) => void;
+}): Promise<boolean>;
+export {};

package/dist/aliSkills.js

@@ -0,0 +1,224 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { executableNames, findExecutable, isExecutable, prependCommandPath, prependNodePath, resolveSpawnCommand, runCommand, } from './process.js';
+const COMMAND_TIMEOUT_MS = 120_000;
+const MAX_OUTPUT_LENGTH = 1_000_000;
+const ANSI_ESCAPE_PATTERN = new RegExp(String.raw `\u001B\[[0-?]*[ -/]*[@-~]`, 'g');
+function existingExecutable(candidates, existsSync) {
+    return candidates.find(candidate => candidate && existsSync(candidate)) ?? null;
+}
+function versionManagerCandidates(home, executableNames, readdirSync) {
+    const roots = [
+        path.join(home, '.nvm', 'versions', 'node'),
+        path.join(home, '.fnm', 'node-versions'),
+    ];
+    return roots.flatMap(root => {
+        try {
+            return readdirSync(root, { withFileTypes: true })
+                .filter(entry => entry.isDirectory())
+                .sort((left, right) => right.name.localeCompare(left.name, undefined, { numeric: true }))
+                .flatMap(entry => executableNames.flatMap(name => [
+                path.join(root, entry.name, 'bin', name),
+                path.join(root, entry.name, 'installation', 'bin', name),
+            ]));
+        }
+        catch {
+            return [];
+        }
+    });
+}
+export function stripAnsi(value) {
+    return value.replace(ANSI_ESCAPE_PATTERN, '');
+}
+export function resolveAliSkillsExecutable(options = {}) {
+    const env = options.env ?? process.env;
+    const home = (options.homedir ?? os.homedir)();
+    const platform = options.platform ?? process.platform;
+    const existsSync = options.existsSync ?? (candidate => isExecutable(candidate, platform));
+    const processExecPath = options.processExecPath ?? process.execPath;
+    const readdirSync = options.readdirSync ?? fs.readdirSync;
+    const names = executableNames('ali-skills', platform);
+    const pathKey = Object.keys(env).find(key => key.toLowerCase() === 'path') || 'PATH';
+    const pathCandidates = (env[pathKey] || '')
+        .split(path.delimiter)
+        .filter(Boolean)
+        .flatMap(directory => names.map(name => path.join(directory, name)));
+    const candidates = [
+        env.MEARL_ALI_SKILLS_PATH,
+        ...names.map(name => path.join(path.dirname(processExecPath), name)),
+        ...names.map(name => path.join(home, '.local', 'bin', name)),
+        ...names.map(name => path.join(home, '.npm-global', 'bin', name)),
+        ...names.map(name => path.join(home, '.volta', 'bin', name)),
+        ...names.map(name => path.join(home, '.local', 'share', 'pnpm', name)),
+        ...names.map(name => path.join(home, 'Library', 'pnpm', name)),
+        ...versionManagerCandidates(home, names, readdirSync),
+        ...(platform === 'win32'
+            ? []
+            : ['/opt/homebrew/bin/ali-skills', '/usr/local/bin/ali-skills', '/usr/bin/ali-skills']),
+        ...pathCandidates,
+    ];
+    return existingExecutable(candidates, existsSync);
+}
+export const runAliSkillsCli = (executable, args, cwd) => new Promise((resolve, reject) => {
+    const launch = resolveSpawnCommand(executable, args);
+    const child = spawn(launch.command, launch.args, {
+        cwd,
+        env: prependNodePath(prependCommandPath(executable)),
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+    });
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+    const append = (current, chunk) => current.length >= MAX_OUTPUT_LENGTH
+        ? current
+        : (current + chunk.toString('utf8')).slice(0, MAX_OUTPUT_LENGTH);
+    const finish = (error) => {
+        if (settled)
+            return;
+        settled = true;
+        clearTimeout(timer);
+        if (error)
+            reject(error);
+        else
+            resolve({ stdout, stderr });
+    };
+    const timer = setTimeout(() => {
+        child.kill('SIGTERM');
+        finish(new Error(`Ali Skills command timed out after ${COMMAND_TIMEOUT_MS / 1000}s`));
+    }, COMMAND_TIMEOUT_MS);
+    child.stdout.on('data', chunk => (stdout = append(stdout, chunk)));
+    child.stderr.on('data', chunk => (stderr = append(stderr, chunk)));
+    child.once('error', error => finish(error));
+    child.once('exit', code => {
+        if (code === 0) {
+            finish();
+            return;
+        }
+        const detail = stripAnsi(stderr || stdout).trim();
+        finish(new Error(detail || `Ali Skills command exited with code ${String(code)}`));
+    });
+});
+export function resolveAliSkillsInvocation(options = {}) {
+    const env = options.env ?? process.env;
+    const executable = resolveAliSkillsExecutable(options);
+    if (executable) {
+        return {
+            command: executable,
+            argsPrefix: [],
+            env: prependNodePath(prependCommandPath(executable, env)),
+        };
+    }
+    const processExecPath = options.processExecPath ?? process.execPath;
+    const npx = findExecutable('npx', {
+        env,
+        existsSync: options.existsSync,
+        platform: options.platform,
+        extraDirectories: [path.dirname(processExecPath)],
+    });
+    if (!npx)
+        return null;
+    return {
+        command: npx,
+        argsPrefix: ['-y', 'ali-skills'],
+        env: prependNodePath(prependCommandPath(npx, env), processExecPath),
+    };
+}
+export function parseGlobalMearlSkillPaths(output) {
+    const parsed = JSON.parse(stripAnsi(output).trim());
+    if (!Array.isArray(parsed))
+        throw new Error('Ali Skills returned an invalid skill list');
+    return [
+        ...new Set(parsed.flatMap((skill) => skill.name === 'mearl' &&
+            skill.scope === 'global' &&
+            typeof skill.path === 'string' &&
+            skill.path.trim()
+            ? [skill.path.trim()]
+            : [])),
+    ];
+}
+export async function runGlobalMearlSkillOperation(operation, options = {}) {
+    const runner = options.runCommand ?? runCommand;
+    const writeLine = options.writeLine ?? (line => console.error(line));
+    const invocation = resolveAliSkillsInvocation(options);
+    if (!invocation) {
+        writeLine('Skill: ali-skills and npx are both unavailable.');
+        return false;
+    }
+    const run = async (args, capture) => {
+        try {
+            return await runner(invocation.command, [...invocation.argsPrefix, ...args], {
+                capture,
+                env: invocation.env,
+                timeoutMs: COMMAND_TIMEOUT_MS,
+            });
+        }
+        catch (error) {
+            writeLine(`Skill: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+    };
+    const listMearlPaths = async () => {
+        const listed = await run(['list', '--global', '--json'], true);
+        if (!listed)
+            return null;
+        if (listed.code !== 0) {
+            writeLine(`Skill: unable to list global skills (exit ${listed.code}).`);
+            const detail = stripAnsi(listed.stderr || listed.stdout).trim();
+            if (detail)
+                writeLine(detail);
+            return null;
+        }
+        try {
+            return parseGlobalMearlSkillPaths(listed.stdout);
+        }
+        catch (error) {
+            writeLine(`Skill: ${error instanceof Error ? error.message : String(error)}.`);
+            return null;
+        }
+    };
+    const paths = await listMearlPaths();
+    if (!paths)
+        return false;
+    if (operation === 'install') {
+        if (paths.length > 0) {
+            writeLine('Skill: already installed:');
+            paths.forEach(skillPath => writeLine(`  ${skillPath}`));
+            return true;
+        }
+        const installed = await run(['add', 'trip/mearl', '--skill', 'mearl', '--global', ...(options.yes ? ['--yes'] : [])], false);
+        if (!installed)
+            return false;
+        if (installed.code !== 0) {
+            writeLine(`Skill: install failed (exit ${installed.code}).`);
+            return false;
+        }
+        const installedPaths = await listMearlPaths();
+        if (!installedPaths || installedPaths.length === 0) {
+            writeLine('Skill: installation finished without a tracked global mearl skill.');
+            return false;
+        }
+        writeLine('Skill: installed.');
+        return true;
+    }
+    if (paths.length === 0) {
+        writeLine('Skill: no tracked global mearl skill found; skipped.');
+        return true;
+    }
+    writeLine('Skill installation:');
+    paths.forEach(skillPath => writeLine(`  ${skillPath}`));
+    const args = operation === 'update'
+        ? ['update', 'mearl', '--global', '--yes']
+        : ['remove', 'mearl', '--global', '--yes'];
+    const result = await run(args, false);
+    if (!result)
+        return false;
+    if (result.code !== 0) {
+        writeLine(`Skill: ${operation} failed (exit ${result.code}).`);
+        return false;
+    }
+    writeLine(`Skill: ${operation === 'update' ? 'updated' : 'uninstalled'}.`);
+    return true;
+}

package/dist/cli.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { type MearlLifecycleOperation } from './lifecycle.js';
+import type { MearlProfile } from './profiles.js';
+interface ParsedArgs {
+    help: boolean;
+    operation?: MearlLifecycleOperation;
+    profile?: MearlProfile;
+    yes: boolean;
+}
+export declare function parseSetupArgs(argv: string[]): ParsedArgs;
+export declare function main(argv?: string[], interactiveTerminal?: boolean): Promise<number>;
+export {};

package/dist/cli.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runMearlLifecycle } from './lifecycle.js';
+export function parseSetupArgs(argv) {
+    if (argv.length === 0 || argv.includes('--help') || argv.includes('-h')) {
+        return { help: true, yes: false };
+    }
+    const operation = argv[0];
+    if (operation !== 'install' && operation !== 'update' && operation !== 'uninstall') {
+        throw new Error(`Unknown operation: ${operation}`);
+    }
+    let profile;
+    let yes = false;
+    for (const arg of argv.slice(1)) {
+        if (arg === '--yes' || arg === '-y' || arg === '--non-interactive') {
+            yes = true;
+            continue;
+        }
+        const candidate = arg === '--local'
+            ? 'local'
+            : arg === '--cloud'
+                ? 'cloud'
+                : arg === '--mcp'
+                    ? 'mcp'
+                    : undefined;
+        if (!candidate)
+            throw new Error(`Unknown option: ${arg}`);
+        if (profile && profile !== candidate) {
+            throw new Error('Choose only one of --local, --cloud, or --mcp');
+        }
+        profile = candidate;
+    }
+    return { help: false, operation, profile, yes };
+}
+function printHelp() {
+    console.error(`Mearl Setup
+
+Usage:
+  npx @mearl/setup <install|update|uninstall> [--local|--cloud|--mcp] [--yes]
+
+Behavior:
+  install      Defaults to --local when no environment is specified
+  update       Auto-detects installed environments from the current PATH
+  uninstall    Auto-detects installed environments and asks for confirmation
+
+Options:
+  --local      Manage @mearl/native-host and @mearl/client
+  --cloud      Manage @mearl/cloud-client
+  --mcp        Manage @mearl/mcp-server and its configuration
+  --yes, -y    Run without prompts and accept detected defaults
+  --non-interactive
+               Alias for --yes, intended for Agents and CI
+  --help, -h   Show this help
+
+Examples:
+  npx @mearl/setup install
+  npx @mearl/setup install --yes
+  npx @mearl/setup install --cloud
+  npx @mearl/setup update
+  npx @mearl/setup uninstall --local`);
+}
+export async function main(argv = process.argv.slice(2), interactiveTerminal = process.stdin.isTTY === true && process.stdout.isTTY === true) {
+    let parsed;
+    try {
+        parsed = parseSetupArgs(argv);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        printHelp();
+        return 2;
+    }
+    if (parsed.help) {
+        printHelp();
+        return 0;
+    }
+    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 runMearlLifecycle({
+            operation: parsed.operation,
+            profile: parsed.profile,
+            yes: parsed.yes,
+        });
+        return ok ? 0 : 1;
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+}
+const currentFile = fileURLToPath(import.meta.url);
+if (process.argv[1] && path.resolve(process.argv[1]) === currentFile) {
+    process.exitCode = await main();
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { buildGlobalPackageCommand, detectGlobalPackage, resolveInvokingPackageManager, resolvePackageManagerInstallation, } from './packageManager.js';
+export type { DetectedGlobalPackage, GlobalPackageCommand, GlobalPackageManager, PackageManagerInstallation, PackageOperation, PackageDetectionOptions, } from './packageManager.js';
+export { runMearlLifecycle } from './lifecycle.js';
+export type { MearlLifecycleDependencies, MearlLifecycleOperation, MearlLifecycleOptions, } from './lifecycle.js';
+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 type { NativeHostCleanupDependencies, NativeHostCleanupOptions, NativeHostIntegrationMode, } from './nativeHost.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export { buildGlobalPackageCommand, detectGlobalPackage, resolveInvokingPackageManager, resolvePackageManagerInstallation, } from './packageManager.js';
+export { runMearlLifecycle } from './lifecycle.js';
+export { MEARL_PROFILES, detectMearlProfiles } from './profiles.js';
+export { MEARL_NATIVE_HOST_NAMES, resolveNativeHostDirectory, uninstallNativeHostArtifacts, } from './nativeHost.js';

package/dist/lifecycle.d.ts

@@ -0,0 +1,24 @@
+import { runGlobalMearlSkillOperation } from './aliSkills.js';
+import { detectGlobalPackage, type PackageManagerInstallation } from './packageManager.js';
+import { type DetectedMearlProfiles, type MearlProfile } from './profiles.js';
+import { uninstallNativeHostArtifacts } from './nativeHost.js';
+import { type CommandRunner } from './process.js';
+export type MearlLifecycleOperation = 'install' | 'update' | 'uninstall';
+export interface MearlLifecycleOptions {
+    operation: MearlLifecycleOperation;
+    profile?: MearlProfile;
+    yes?: boolean;
+    env?: NodeJS.ProcessEnv;
+}
+export interface MearlLifecycleDependencies {
+    cleanupNativeHost?: typeof uninstallNativeHostArtifacts;
+    confirm?: (message: string) => Promise<boolean>;
+    detectPackage?: typeof detectGlobalPackage;
+    detectProfiles?: (env: NodeJS.ProcessEnv) => DetectedMearlProfiles;
+    existsSync?: (filePath: string) => boolean;
+    resolveInvokingManager?: (env: NodeJS.ProcessEnv) => PackageManagerInstallation;
+    runCommand?: CommandRunner;
+    runSkillOperation?: typeof runGlobalMearlSkillOperation;
+    writeLine?: (line: string) => void;
+}
+export declare function runMearlLifecycle(options: MearlLifecycleOptions, dependencies?: MearlLifecycleDependencies): Promise<boolean>;

package/dist/lifecycle.js

@@ -0,0 +1,221 @@
+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 { runGlobalMearlSkillOperation } from './aliSkills.js';
+import { buildGlobalPackageCommand, detectGlobalPackage, resolveInvokingPackageManager, } from './packageManager.js';
+import { MEARL_PROFILES, detectMearlProfiles, } from './profiles.js';
+import { uninstallNativeHostArtifacts } from './nativeHost.js';
+import { executableNames, prependCommandPath, runCommand, } from './process.js';
+async function confirmInTerminal(message) {
+    if (!input.isTTY || !output.isTTY)
+        return false;
+    const readline = createInterface({ input, output });
+    try {
+        const answer = (await readline.question(`${message} [y/N] `)).trim().toLowerCase();
+        return answer === 'y' || answer === 'yes';
+    }
+    finally {
+        readline.close();
+    }
+}
+function siblingExecutable(anchor, name, existsSync) {
+    for (const executableName of executableNames(name)) {
+        const candidate = path.join(path.dirname(anchor), executableName);
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+async function runLifecycleCommand(runner, command, args, env, label, writeLine) {
+    try {
+        return await runner(command, args, {
+            capture: false,
+            env: prependCommandPath(command, env),
+        });
+    }
+    catch (error) {
+        writeLine(`${label}: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+async function runHook(profile, operation, detected, runner, existsSync, env, writeLine, yes) {
+    let executable;
+    let args;
+    if (profile === 'local' && operation !== 'uninstall') {
+        executable = detected.executable;
+        args = ['--init', '--mode', 'skills'];
+    }
+    else if (profile === 'mcp' && operation === 'uninstall') {
+        executable = siblingExecutable(detected.executable, 'mearl-mcp-uninstall', existsSync);
+        args = ['--managed-by-setup', ...(yes ? ['--yes'] : [])];
+    }
+    else if (profile === 'mcp' && operation === 'install') {
+        executable = siblingExecutable(detected.executable, 'mearl-mcp-configure', existsSync);
+        args = ['--global-install', ...(yes ? ['--yes'] : [])];
+    }
+    else if (profile === 'mcp' && operation === 'update') {
+        executable = siblingExecutable(detected.executable, 'mearl-mcp-configure', existsSync);
+        args = ['--skip-mcp', '--global-install'];
+    }
+    else {
+        return true;
+    }
+    if (!executable) {
+        writeLine(`Hook: ${profile} ${operation} command was not found.`);
+        return false;
+    }
+    const result = await runLifecycleCommand(runner, executable, args, env, `Hook: ${profile} ${operation}`, writeLine);
+    if (!result)
+        return false;
+    if (result.code !== 0) {
+        writeLine(`Hook: ${profile} ${operation} failed (exit ${result.code}).`);
+        return false;
+    }
+    return true;
+}
+function selectedProfiles(operation, requested, detected) {
+    if (requested)
+        return [requested];
+    if (operation === 'install')
+        return ['local'];
+    return [...detected.keys()];
+}
+function operationVerb(operation) {
+    return operation === 'uninstall' ? 'uninstall' : operation === 'update' ? 'update' : 'install';
+}
+export async function runMearlLifecycle(options, dependencies = {}) {
+    const env = options.env ?? process.env;
+    const writeLine = dependencies.writeLine ?? (line => console.error(line));
+    const existsSync = dependencies.existsSync ?? fs.existsSync;
+    const runner = dependencies.runCommand ?? runCommand;
+    const cleanupNativeHost = dependencies.cleanupNativeHost ?? uninstallNativeHostArtifacts;
+    const detectPackage = dependencies.detectPackage ?? detectGlobalPackage;
+    const detectProfiles = dependencies.detectProfiles ?? (childEnv => detectMearlProfiles({ env: childEnv }));
+    const resolveInvokingManager = dependencies.resolveInvokingManager ??
+        (childEnv => resolveInvokingPackageManager({ env: childEnv }));
+    const runSkill = dependencies.runSkillOperation ?? runGlobalMearlSkillOperation;
+    const confirm = dependencies.confirm ?? confirmInTerminal;
+    const detected = detectProfiles(env);
+    const selected = selectedProfiles(options.operation, options.profile, detected);
+    if (selected.length === 0) {
+        writeLine('No installed Mearl environment was detected on the current PATH.');
+        if (options.operation === 'uninstall')
+            return true;
+        writeLine('Run: npx @mearl/setup install');
+        return false;
+    }
+    if (options.operation === 'update') {
+        const missing = selected.filter(profile => !detected.has(profile));
+        if (missing.length > 0) {
+            writeLine(`Not installed: ${missing.join(', ')}. Run the install command first.`);
+            return false;
+        }
+    }
+    if (options.operation === 'uninstall') {
+        const installedSelected = selected.filter(profile => detected.has(profile));
+        if (installedSelected.length === 0) {
+            writeLine(`Nothing to uninstall for ${selected.join(', ')}.`);
+            return true;
+        }
+        if (!options.yes &&
+            !(await confirm(`Uninstall Mearl environments: ${installedSelected.join(', ')}?`))) {
+            writeLine('Uninstall cancelled.');
+            return false;
+        }
+    }
+    writeLine(`${operationVerb(options.operation)} targets: ${selected
+        .map(profile => MEARL_PROFILES[profile].label)
+        .join(', ')}`);
+    let packagesOk = true;
+    for (const profile of selected) {
+        const config = MEARL_PROFILES[profile];
+        const current = detected.get(profile);
+        if (options.operation === 'uninstall' && !current)
+            continue;
+        const installation = current ?? resolveInvokingManager(env);
+        if (options.operation === 'uninstall' && profile === 'local') {
+            const keepsMcp = detected.has('mcp') && !selected.includes('mcp');
+            let cleanupOk = false;
+            try {
+                cleanupOk = cleanupNativeHost({
+                    mode: keepsMcp ? 'skills' : 'both',
+                    silent: true,
+                });
+            }
+            catch (error) {
+                writeLine(`Native host: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            writeLine(`Native host: ${cleanupOk ? 'cleaned.' : 'cleanup failed.'}`);
+            if (!cleanupOk) {
+                packagesOk = false;
+                continue;
+            }
+        }
+        if (options.operation === 'uninstall' &&
+            !(await runHook(profile, options.operation, current, runner, existsSync, env, writeLine, options.yes === true))) {
+            packagesOk = false;
+            continue;
+        }
+        const packageOperation = options.operation === 'uninstall' ? 'uninstall' : options.operation;
+        const command = buildGlobalPackageCommand(installation, packageOperation, config.packages);
+        writeLine(`Packages (${profile}): ${command.manager}`);
+        const result = await runLifecycleCommand(runner, command.command, command.args, env, `Packages (${profile})`, writeLine);
+        if (!result) {
+            packagesOk = false;
+            continue;
+        }
+        if (result.code !== 0) {
+            writeLine(`Packages (${profile}): failed (exit ${result.code}).`);
+            packagesOk = false;
+            continue;
+        }
+        if (options.operation !== 'uninstall' && (profile === 'local' || profile === 'mcp')) {
+            const refreshed = detectPackage(config.anchorPackage, config.anchorBins, {
+                env: prependCommandPath(command.command, env),
+            }) ?? current;
+            if (!refreshed ||
+                !(await runHook(profile, options.operation, refreshed, runner, existsSync, env, writeLine, options.yes === true))) {
+                packagesOk = false;
+            }
+        }
+    }
+    let skillOk = true;
+    const selectedUsesSkill = selected.some(profile => MEARL_PROFILES[profile].usesSkill);
+    if (packagesOk && selectedUsesSkill) {
+        try {
+            if (options.operation === 'uninstall') {
+                const remainingSkillProfiles = ['local', 'cloud'].filter(profile => detected.has(profile) && !selected.includes(profile));
+                if (remainingSkillProfiles.length > 0) {
+                    writeLine(`Skill: kept for ${remainingSkillProfiles.join(', ')}.`);
+                }
+                else {
+                    skillOk = await runSkill('uninstall', {
+                        env,
+                        yes: options.yes,
+                        writeLine,
+                        runCommand: runner,
+                    });
+                }
+            }
+            else {
+                skillOk = await runSkill(options.operation, {
+                    env,
+                    yes: options.yes,
+                    writeLine,
+                    runCommand: runner,
+                });
+            }
+        }
+        catch (error) {
+            writeLine(`Skill: ${error instanceof Error ? error.message : String(error)}`);
+            skillOk = false;
+        }
+    }
+    if (packagesOk && skillOk) {
+        writeLine('Mearl setup complete.');
+        return true;
+    }
+    writeLine('Mearl setup incomplete. Review the messages above.');
+    return false;
+}

package/dist/nativeHost.d.ts

@@ -0,0 +1,19 @@
+import fs from 'node:fs';
+export type NativeHostIntegrationMode = 'skills' | 'mcp';
+export declare const MEARL_NATIVE_HOST_NAMES: Record<NativeHostIntegrationMode, string>;
+export interface NativeHostCleanupOptions {
+    mode?: NativeHostIntegrationMode | 'both';
+    silent?: boolean;
+}
+export interface NativeHostCleanupDependencies {
+    env?: NodeJS.ProcessEnv;
+    existsSync?: typeof fs.existsSync;
+    homedir?: () => string;
+    hostDir?: string;
+    platform?: NodeJS.Platform;
+    unlinkSync?: typeof fs.unlinkSync;
+    unregisterWindowsNativeHost?: (hostName: string) => void;
+    writeLine?: (line: string) => void;
+}
+export declare function resolveNativeHostDirectory(options?: Pick<NativeHostCleanupDependencies, 'env' | 'homedir' | 'platform'>): string;
+export declare function uninstallNativeHostArtifacts(options?: NativeHostCleanupOptions, dependencies?: NativeHostCleanupDependencies): boolean;

package/dist/nativeHost.js

@@ -0,0 +1,75 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+export const MEARL_NATIVE_HOST_NAMES = {
+    skills: 'com.alibaba.mearl.skills',
+    mcp: 'com.alibaba.mearl.mcp',
+};
+export function resolveNativeHostDirectory(options = {}) {
+    const env = options.env ?? process.env;
+    const home = (options.homedir ?? os.homedir)();
+    switch (options.platform ?? process.platform) {
+        case 'darwin':
+            return path.join(home, 'Library/Application Support/Google/Chrome/NativeMessagingHosts');
+        case 'linux':
+            return path.join(home, '.config/google-chrome/NativeMessagingHosts');
+        case 'win32':
+            return path.join(env.PROGRAMDATA || 'C:\\ProgramData', 'Google\\Chrome\\NativeMessagingHosts');
+        default:
+            throw new Error(`Unsupported platform: ${String(options.platform ?? process.platform)}`);
+    }
+}
+function unregisterWindowsNativeHost(hostName) {
+    const registryKey = `HKCU\\SOFTWARE\\Google\\Chrome\\NativeMessagingHosts\\${hostName}`;
+    try {
+        execFileSync('reg', ['delete', registryKey, '/f'], { stdio: 'pipe' });
+    }
+    catch {
+        // A missing registry key is already the desired state.
+    }
+}
+export function uninstallNativeHostArtifacts(options = {}, dependencies = {}) {
+    const { mode = 'both', silent = false } = options;
+    if (mode === 'both') {
+        return ['skills', 'mcp']
+            .map(integrationMode => uninstallNativeHostArtifacts({ ...options, mode: integrationMode }, dependencies))
+            .every(Boolean);
+    }
+    const writeLine = dependencies.writeLine ?? (line => console.error(line));
+    const log = (line) => {
+        if (!silent)
+            writeLine(line);
+    };
+    try {
+        const existsSync = dependencies.existsSync ?? fs.existsSync;
+        const platform = dependencies.platform ?? process.platform;
+        const hostDir = dependencies.hostDir ??
+            resolveNativeHostDirectory({
+                env: dependencies.env,
+                homedir: dependencies.homedir,
+                platform,
+            });
+        const unlinkSync = dependencies.unlinkSync ?? fs.unlinkSync;
+        const unregister = dependencies.unregisterWindowsNativeHost ?? unregisterWindowsNativeHost;
+        const hostName = MEARL_NATIVE_HOST_NAMES[mode];
+        const launcherExtension = platform === 'win32' ? 'cmd' : 'sh';
+        const artifacts = [
+            path.join(hostDir, `${hostName}.json`),
+            path.join(hostDir, `${hostName}-launcher.${launcherExtension}`),
+        ];
+        for (const artifact of artifacts) {
+            if (!existsSync(artifact))
+                continue;
+            unlinkSync(artifact);
+            log(`✅ Removed: ${artifact}`);
+        }
+        if (platform === 'win32')
+            unregister(hostName);
+        return true;
+    }
+    catch (error) {
+        log(`❌ Uninstall failed: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+}

package/dist/packageManager.d.ts

@@ -0,0 +1,31 @@
+export type GlobalPackageManager = 'npm' | 'pnpm' | 'yarn' | 'bun' | 'volta';
+export type PackageOperation = 'install' | 'update' | 'uninstall';
+export interface PackageManagerInstallation {
+    manager: GlobalPackageManager;
+    command: string;
+}
+export interface GlobalPackageCommand extends PackageManagerInstallation {
+    args: string[];
+}
+export interface DetectedGlobalPackage extends PackageManagerInstallation {
+    packageName: string;
+    packageRoot: string;
+    executable: string;
+}
+export interface PackageDetectionOptions {
+    env?: NodeJS.ProcessEnv;
+    existsSync?: (filePath: string) => boolean;
+    platform?: NodeJS.Platform;
+    processExecPath?: string;
+    readFileSync?: (filePath: string, encoding: BufferEncoding) => string;
+    realpathSync?: (filePath: string) => string;
+}
+export declare function resolvePackageManagerInstallation(packageRoot: string, packageName: string, options?: PackageDetectionOptions): PackageManagerInstallation | null;
+export declare function buildGlobalPackageCommand(installation: PackageManagerInstallation, operation: PackageOperation, packages: string[]): GlobalPackageCommand;
+export declare function resolveInvokingPackageManager(options?: {
+    env?: NodeJS.ProcessEnv;
+    existsSync?: (filePath: string) => boolean;
+    platform?: NodeJS.Platform;
+    processExecPath?: string;
+}): PackageManagerInstallation;
+export declare function detectGlobalPackage(packageName: string, binNames: string[], options?: PackageDetectionOptions): DetectedGlobalPackage | null;

package/dist/packageManager.js

@@ -0,0 +1,200 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { executableNames, findExecutable, isExecutable } from './process.js';
+function normalizePath(filePath) {
+    return filePath.replaceAll('\\', '/').replace(/\/+$/, '');
+}
+function firstExisting(candidates, existsSync) {
+    return candidates.find(candidate => existsSync(candidate));
+}
+function fallbackCommand(name, platform) {
+    if (platform !== 'win32')
+        return name;
+    if (name === 'bun' || name === 'volta')
+        return `${name}.exe`;
+    return `${name}.cmd`;
+}
+export function resolvePackageManagerInstallation(packageRoot, packageName, options = {}) {
+    const env = options.env ?? process.env;
+    const platform = options.platform ?? process.platform;
+    const existsSync = options.existsSync ?? (candidate => isExecutable(candidate, platform));
+    const processExecPath = options.processExecPath ?? process.execPath;
+    const normalizedRoot = normalizePath(path.resolve(packageRoot));
+    const lowerRoot = normalizedRoot.toLowerCase();
+    const lowerPackageName = packageName.toLowerCase();
+    const pnpmGlobalRoot = /\/global\/\d+\/(?:\.pnpm\/.*\/)?node_modules\//.exec(lowerRoot);
+    if (pnpmGlobalRoot && lowerRoot.endsWith(`/node_modules/${lowerPackageName}`)) {
+        const pnpmHome = normalizedRoot.slice(0, pnpmGlobalRoot.index);
+        const command = firstExisting([
+            ...executableNames('pnpm', platform).map(name => path.join(pnpmHome, name)),
+            ...executableNames('pnpm', platform).map(name => path.join(path.dirname(processExecPath), name)),
+        ], existsSync) ?? fallbackCommand('pnpm', platform);
+        return { manager: 'pnpm', command };
+    }
+    const bunMarker = `/.bun/install/global/node_modules/${lowerPackageName}`;
+    if (lowerRoot.endsWith(bunMarker)) {
+        const bunHome = normalizedRoot.slice(0, lowerRoot.indexOf('/.bun/'));
+        const command = firstExisting(executableNames('bun', platform).map(name => path.join(bunHome, '.bun', 'bin', name)), existsSync) ?? fallbackCommand('bun', platform);
+        return { manager: 'bun', command };
+    }
+    if ((lowerRoot.includes('/.config/yarn/global/node_modules/') ||
+        lowerRoot.includes('/.yarn/global/node_modules/') ||
+        lowerRoot.includes('/yarn/global/node_modules/') ||
+        lowerRoot.includes('/yarn/data/global/node_modules/')) &&
+        lowerRoot.endsWith(`/node_modules/${lowerPackageName}`)) {
+        return { manager: 'yarn', command: fallbackCommand('yarn', platform) };
+    }
+    if (lowerRoot.includes('/.volta/tools/image/packages/') &&
+        lowerRoot.endsWith(`/lib/node_modules/${lowerPackageName}`)) {
+        const voltaHome = normalizedRoot.slice(0, lowerRoot.indexOf('/.volta/'));
+        const command = firstExisting(executableNames('volta', platform).map(name => path.join(voltaHome, '.volta', 'bin', name)), existsSync) ?? fallbackCommand('volta', platform);
+        return { manager: 'volta', command };
+    }
+    const npmMarker = `/lib/node_modules/${lowerPackageName}`;
+    if (lowerRoot.endsWith(npmMarker)) {
+        const prefix = normalizedRoot.slice(0, lowerRoot.length - npmMarker.length);
+        const command = firstExisting([
+            ...executableNames('npm', platform).map(name => path.join(prefix, 'bin', name)),
+            ...executableNames('npm', platform).map(name => path.join(path.dirname(processExecPath), name)),
+        ], existsSync) ?? fallbackCommand('npm', platform);
+        return { manager: 'npm', command };
+    }
+    if (platform === 'win32' && env.APPDATA) {
+        const npmRoot = normalizePath(path.join(env.APPDATA, 'npm', 'node_modules', packageName));
+        if (lowerRoot === npmRoot.toLowerCase()) {
+            return { manager: 'npm', command: fallbackCommand('npm', platform) };
+        }
+    }
+    return null;
+}
+export function buildGlobalPackageCommand(installation, operation, packages) {
+    const targets = operation === 'uninstall' ? packages : packages.map(packageName => `${packageName}@latest`);
+    let args;
+    switch (installation.manager) {
+        case 'npm':
+            args =
+                operation === 'uninstall' ? ['uninstall', '-g', ...targets] : ['install', '-g', ...targets];
+            break;
+        case 'pnpm':
+            args = operation === 'uninstall' ? ['remove', '-g', ...targets] : ['add', '-g', ...targets];
+            break;
+        case 'yarn':
+            args =
+                operation === 'uninstall'
+                    ? ['global', 'remove', ...targets]
+                    : ['global', 'add', ...targets];
+            break;
+        case 'bun':
+            args = operation === 'uninstall' ? ['remove', '-g', ...targets] : ['add', '-g', ...targets];
+            break;
+        case 'volta':
+            args = operation === 'uninstall' ? ['uninstall', ...targets] : ['install', ...targets];
+            break;
+    }
+    return { ...installation, args };
+}
+export function resolveInvokingPackageManager(options = {}) {
+    const env = options.env ?? process.env;
+    const existsSync = options.existsSync ?? fs.existsSync;
+    const platform = options.platform ?? process.platform;
+    const processExecPath = options.processExecPath ?? process.execPath;
+    const userAgent = (env.npm_config_user_agent ?? '').toLowerCase();
+    const manager = userAgent.startsWith('pnpm/')
+        ? 'pnpm'
+        : userAgent.startsWith('yarn/')
+            ? 'yarn'
+            : userAgent.startsWith('bun/')
+                ? 'bun'
+                : 'npm';
+    const sibling = firstExisting(executableNames(manager, platform).map(name => path.join(path.dirname(processExecPath), name)), existsSync);
+    return { manager, command: sibling ?? fallbackCommand(manager, platform) };
+}
+function readPackageName(packageRoot, readFileSync) {
+    try {
+        const parsed = JSON.parse(readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
+        return typeof parsed.name === 'string' ? parsed.name : null;
+    }
+    catch {
+        return null;
+    }
+}
+function findPackageRoot(entryPath, packageName, readFileSync) {
+    let current = path.dirname(entryPath);
+    for (let depth = 0; depth < 12; depth += 1) {
+        if (readPackageName(current, readFileSync) === packageName)
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return null;
+}
+function packageRootFromWrapper(executable, packageName, readFileSync) {
+    try {
+        const content = readFileSync(executable, 'utf8').slice(0, 32_000).replaceAll('\\', '/');
+        const escapedName = packageName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const packageSuffix = `node_modules/${escapedName}`;
+        const wrapperDirectory = path.dirname(executable);
+        const candidates = [];
+        // npm and pnpm wrappers resolve their entry point relative to the bin
+        // directory. Preserve the complete relative prefix because pnpm places
+        // packages below global/<version>/.pnpm rather than bin/node_modules.
+        const relativePattern = new RegExp(`(?:\\$basedir|%~?dp0%?)/([^"'\\r\\n]*?${packageSuffix})(?=/|["'\\s])`, 'gi');
+        for (const match of content.matchAll(relativePattern)) {
+            candidates.push(path.resolve(wrapperDirectory, match[1].replaceAll('/', path.sep)));
+        }
+        // Some package managers emit an absolute package entry in the wrapper.
+        const absolutePattern = new RegExp(`((?:[A-Za-z]:)?/[^"'\\r\\n:]*?${packageSuffix})(?=/|["'\\s:])`, 'gi');
+        for (const match of content.matchAll(absolutePattern)) {
+            candidates.push(path.resolve(match[1].replaceAll('/', path.sep)));
+        }
+        for (const candidate of new Set(candidates)) {
+            if (readPackageName(candidate, readFileSync) === packageName)
+                return candidate;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function detectGlobalPackage(packageName, binNames, options = {}) {
+    const env = options.env ?? process.env;
+    const platform = options.platform ?? process.platform;
+    const existsSync = options.existsSync ?? (candidate => isExecutable(candidate, platform));
+    const readFileSync = options.readFileSync ?? fs.readFileSync;
+    const realpathSync = options.realpathSync ?? fs.realpathSync;
+    const processExecPath = options.processExecPath ?? process.execPath;
+    const extraDirectories = [path.dirname(processExecPath)];
+    for (const binName of binNames) {
+        const executable = findExecutable(binName, {
+            env,
+            existsSync,
+            platform,
+            extraDirectories,
+        });
+        if (!executable)
+            continue;
+        let packageRoot = null;
+        try {
+            packageRoot = findPackageRoot(realpathSync(executable), packageName, readFileSync);
+        }
+        catch {
+            // Windows package-manager wrappers are regular files rather than symlinks.
+        }
+        packageRoot ??= packageRootFromWrapper(executable, packageName, readFileSync);
+        if (!packageRoot)
+            continue;
+        const installation = resolvePackageManagerInstallation(packageRoot, packageName, {
+            env,
+            existsSync,
+            platform,
+            processExecPath,
+        });
+        if (!installation)
+            continue;
+        return { packageName, packageRoot, executable, ...installation };
+    }
+    return null;
+}

package/dist/process.d.ts

@@ -0,0 +1,28 @@
+export interface SpawnCommand {
+    command: string;
+    args: string[];
+}
+export interface CommandResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+export interface RunCommandOptions {
+    capture?: boolean;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+}
+export type CommandRunner = (command: string, args: string[], options?: RunCommandOptions) => Promise<CommandResult>;
+export declare function isExecutable(filePath: string, platform?: NodeJS.Platform): boolean;
+export declare function executableNames(name: string, platform?: NodeJS.Platform): string[];
+export declare function resolveSpawnCommand(executable: string, args: string[], platform?: NodeJS.Platform, commandInterpreter?: string | undefined): SpawnCommand;
+export declare function prependCommandPath(command: string, env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function prependNodePath(env?: NodeJS.ProcessEnv, nodeExecutable?: string): NodeJS.ProcessEnv;
+export declare function findExecutable(name: string, options?: {
+    env?: NodeJS.ProcessEnv;
+    existsSync?: (filePath: string) => boolean;
+    platform?: NodeJS.Platform;
+    extraDirectories?: string[];
+}): string | null;
+export declare const runCommand: CommandRunner;

package/dist/process.js

@@ -0,0 +1,98 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+const MAX_CAPTURE_LENGTH = 1_000_000;
+export function isExecutable(filePath, platform = process.platform) {
+    try {
+        fs.accessSync(filePath, platform === 'win32' ? fs.constants.F_OK : fs.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function executableNames(name, platform = process.platform) {
+    return platform === 'win32' ? [`${name}.cmd`, `${name}.exe`, name] : [name];
+}
+export function resolveSpawnCommand(executable, args, platform = process.platform, commandInterpreter = process.env.ComSpec) {
+    if (platform === 'win32' && /\.(?:cmd|bat)$/i.test(executable)) {
+        return {
+            command: commandInterpreter || 'cmd.exe',
+            args: ['/d', '/s', '/c', executable, ...args],
+        };
+    }
+    return { command: executable, args };
+}
+export function prependCommandPath(command, env = process.env) {
+    if (!path.isAbsolute(command))
+        return env;
+    return prependPath(path.dirname(command), env);
+}
+export function prependNodePath(env = process.env, nodeExecutable = process.execPath) {
+    return prependPath(path.dirname(nodeExecutable), env);
+}
+function prependPath(directory, env) {
+    const pathKey = Object.keys(env).find(key => key.toLowerCase() === 'path') || 'PATH';
+    const inherited = env[pathKey] || '';
+    const entries = inherited.split(path.delimiter).filter(Boolean);
+    if (entries.includes(directory))
+        return env;
+    return { ...env, [pathKey]: [directory, ...entries].join(path.delimiter) };
+}
+export function findExecutable(name, options = {}) {
+    const env = options.env ?? process.env;
+    const platform = options.platform ?? process.platform;
+    const existsSync = options.existsSync ?? (candidate => isExecutable(candidate, platform));
+    const pathKey = Object.keys(env).find(key => key.toLowerCase() === 'path') || 'PATH';
+    const directories = [
+        ...(options.extraDirectories ?? []),
+        ...(env[pathKey] ?? '').split(path.delimiter).filter(Boolean),
+    ];
+    for (const directory of directories) {
+        for (const executableName of executableNames(name, platform)) {
+            const candidate = path.join(directory, executableName);
+            if (existsSync(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}
+export const runCommand = (command, args, options = {}) => new Promise((resolve, reject) => {
+    const capture = options.capture === true;
+    const launch = resolveSpawnCommand(command, args);
+    const child = spawn(launch.command, launch.args, {
+        cwd: options.cwd,
+        env: options.env,
+        stdio: capture ? ['ignore', 'pipe', 'pipe'] : 'inherit',
+        windowsHide: true,
+    });
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+    const append = (current, chunk) => current.length >= MAX_CAPTURE_LENGTH
+        ? current
+        : (current + chunk.toString('utf8')).slice(0, MAX_CAPTURE_LENGTH);
+    const finish = (error, code = 1) => {
+        if (settled)
+            return;
+        settled = true;
+        if (timer)
+            clearTimeout(timer);
+        if (error)
+            reject(error);
+        else
+            resolve({ code, stdout, stderr });
+    };
+    const timer = options.timeoutMs === undefined
+        ? undefined
+        : setTimeout(() => {
+            child.kill('SIGTERM');
+            finish(new Error(`Command timed out after ${options.timeoutMs}ms`));
+        }, options.timeoutMs);
+    if (capture) {
+        child.stdout?.on('data', chunk => (stdout = append(stdout, chunk)));
+        child.stderr?.on('data', chunk => (stderr = append(stderr, chunk)));
+    }
+    child.once('error', error => finish(error));
+    child.once('close', code => finish(undefined, code ?? 1));
+});

package/dist/profiles.d.ts

@@ -0,0 +1,13 @@
+import { detectGlobalPackage, type DetectedGlobalPackage } from './packageManager.js';
+export type MearlProfile = 'local' | 'cloud' | 'mcp';
+export interface MearlProfileConfig {
+    id: MearlProfile;
+    label: string;
+    anchorPackage: string;
+    anchorBins: string[];
+    packages: string[];
+    usesSkill: boolean;
+}
+export declare const MEARL_PROFILES: Record<MearlProfile, MearlProfileConfig>;
+export type DetectedMearlProfiles = Map<MearlProfile, DetectedGlobalPackage>;
+export declare function detectMearlProfiles(options?: Parameters<typeof detectGlobalPackage>[2]): DetectedMearlProfiles;

package/dist/profiles.js

@@ -0,0 +1,36 @@
+import { detectGlobalPackage } from './packageManager.js';
+export const MEARL_PROFILES = {
+    local: {
+        id: 'local',
+        label: 'local browser',
+        anchorPackage: '@mearl/native-host',
+        anchorBins: ['mearl-native-host'],
+        packages: ['@mearl/native-host', '@mearl/client'],
+        usesSkill: true,
+    },
+    cloud: {
+        id: 'cloud',
+        label: 'cloud agent',
+        anchorPackage: '@mearl/cloud-client',
+        anchorBins: ['mearl-cloud'],
+        packages: ['@mearl/cloud-client'],
+        usesSkill: true,
+    },
+    mcp: {
+        id: 'mcp',
+        label: 'MCP',
+        anchorPackage: '@mearl/mcp-server',
+        anchorBins: ['mearl-mcp-server'],
+        packages: ['@mearl/mcp-server'],
+        usesSkill: false,
+    },
+};
+export function detectMearlProfiles(options = {}) {
+    const detected = new Map();
+    for (const profile of Object.values(MEARL_PROFILES)) {
+        const installation = detectGlobalPackage(profile.anchorPackage, profile.anchorBins, options);
+        if (installation)
+            detected.set(profile.id, installation);
+    }
+    return detected;
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@mearl/setup",
+  "version": "2.2.2",
+  "description": "One-shot installer, updater, and uninstaller for Mearl environments",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./ali-skills": {
+      "types": "./dist/aliSkills.d.ts",
+      "import": "./dist/aliSkills.js"
+    },
+    "./process": {
+      "types": "./dist/process.d.ts",
+      "import": "./dist/process.js"
+    },
+    "./native-host": {
+      "types": "./dist/nativeHost.d.ts",
+      "import": "./dist/nativeHost.js"
+    }
+  },
+  "bin": {
+    "mearl-setup": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "mearl",
+    "setup",
+    "installer",
+    "update",
+    "uninstall"
+  ],
+  "license": "ISC",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "devDependencies": {
+    "@types/node": "^24.9.1",
+    "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "build": "rm -rf dist/ && tsc && chmod +x dist/cli.js",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}