npm - @mearl/setup - Versions diffs - 3.0.0-beta.4 → 3.0.0-beta.7 - Mend

@mearl/setup 3.0.0-beta.4 → 3.0.0-beta.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/README.md CHANGED Viewed

@@ -4,31 +4,32 @@
 Mearl 环境的一次性安装、更新、卸载与配置工具。无需先全局安装 setup：
+要求 Node.js >= 20.18.0。安装前检查 `node --version`；3.0 beta 继续显式使用 `@beta`，
+避免 npm 在未指定版本时按旧 Node 的兼容性选到历史安装器。
 ```bash
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta [install] [--local] [--cloud|--qoder-cloud] [--mcp]
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta update [--local] [--cloud|--qoder-cloud] [--mcp]
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta uninstall [--local] [--cloud|--qoder-cloud] [--mcp] [--full]
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta extension [--full] [--force]
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta plugin [name] <path>
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta plugin install <skills add 参数...>
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta plugin uninstall <name>
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta provider <install|update|uninstall> <package|id>
+npx @mearl/setup@beta [install] [--local] [--cloud] [--cloud-mode <id>] [--mcp]
+npx @mearl/setup@beta update [--local] [--cloud] [--cloud-mode <id>] [--mcp]
+npx @mearl/setup@beta uninstall [--local] [--cloud] [--cloud-mode <id>] [--mcp] [--full]
+npx @mearl/setup@beta extension [--full] [--force]
+npx @mearl/setup@beta plugin [name] <path>
+npx @mearl/setup@beta plugin install <skills add 参数...>
+npx @mearl/setup@beta plugin uninstall <name>
+npx @mearl/setup@beta provider <install|update|uninstall> <package|id>
+npx @mearl/setup@beta preset repair [--replace-skill <name> ...]
 ```
 浏览器 Provider 独立安装和演进。安装后运行 `mearl <providerId>` 查看该版本声明的能力、
 配置和启动参数。
-在 Qoder Cloud Agent 环境中，使用 `npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta --qoder-cloud --yes` 选择 Qoder
-配对模式。它与 `--cloud` 安装同一套 cloud-server、client 和 Skill，只把 cloud-server
-模式记录为 Qoder；`mearl-cloud-server` 的命令交互保持不变，`start` 和 `restart` 输出新的
-配对指令后退出，不监听端口或保留守护进程。配对 URL 不包含 Qoder PAT。
+可选云协议先通过 preset 安装对应能力，再用 `--cloud-mode <id>` 选择。Qoder 配对见 [`@mearl/plugin-qoder`](../plugin-qoder/README.md)；setup 不默认包含或安装它。
 ## 安装与注册 Skill 插件
 一个命令安装 skill 并注册它的 CLI、SDK 和 MCP 能力：
 ```bash
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta plugin install https://github.com/F-loat/mearl/tree/v3.0.0-beta.1 --skill browser-tab-manager --yes
+npx @mearl/setup@beta plugin install https://github.com/mearlhq/mearl/tree/codex/open-source-ready --skill browser-tab-manager --yes
 mearl tabs summary
 ```
@@ -38,6 +39,14 @@ mearl tabs summary
 Native preset 批次新建的插件注册使用 setup 托管归属，后续通过 Agent 更新仍保留该归属；同目录已有的用户注册保持原归属，自定义用户别名也会保留。托管卸载遇到用户别名共用同一 Skill 时，只清除托管注册并保留 Skill 文件。
+GUI 和 CLI 使用同一套 preset 安装器及覆盖规则。已保存的安装尚未完成时，运行 `preset repair` 从接受的本地资源重试，不重新下载 preset，也不隐式覆盖冲突来源。显式重复指定 `--replace-skill` 即授权本次替换这些 Skill 的来源或同名旧插件注册：
+```bash
+npx @mearl/setup@beta preset repair --replace-skill example-skill --replace-skill another-skill
+```
+已安装的 Skill 仅修复注册；来源冲突项重新安装。未列出的冲突仍会阻止安装，声明外的工具名与变更后的安装身份也会被拒绝。覆盖授权不会保留到后续普通修复或自动更新。缺少浏览器权限时仍需在扩展中授权。输出沿用 preset JSON，已就绪退出 `0`、仍有待完成项退出 `3`、安装失败退出 `1`，无效参数退出 `2`。
 自动注册默认使用安装目录名；入口可声明 `name` 指定简短命令名。
 重装会刷新同名绑定。JavaScript 入口必须默认导出 `register(app)`，Python 入口必须导出 `register(app)` 函数；完整协议见
 [插件运行时合同](../../docs/plugin-runtime.md)。
@@ -45,8 +54,8 @@ Native preset 批次新建的插件注册使用 setup 托管归属，后续通
 已通过其他渠道分发的 skill 或自定义入口，可以直接传入路径注册：
 ```bash
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta plugin /absolute/path/to/browser-tab-manager
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta plugin custom ./skills/custom/entry.mjs
+npx @mearl/setup@beta plugin /absolute/path/to/browser-tab-manager
+npx @mearl/setup@beta plugin custom ./skills/custom/entry.mjs
 ```
 path 接受目录或具体文件；目录默认读取 `scripts/main.mjs` 或 `scripts/main.py`，相对路径基于调用工作目录解析。插件名优先使用显式 name，其次读取入口的 `name` metadata，最后回退到 Skill 目录名；常规注册只传 path，显式 name 仅用于覆盖或兼容旧入口。Python 插件要求 `python3 >= 3.9`，可通过 `MEARL_PYTHON` 指定解释器路径；setup 只验证入口可加载，不安装 Python，也不执行 `pip install`。
@@ -59,7 +68,7 @@ native-host 会幂等初始化 Skills 模式。基础环境补齐或初始化失
 不再需要插件时执行：
 ```bash
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta plugin uninstall tabs
+npx @mearl/setup@beta plugin uninstall tabs
 ```
 若入口位于 `~/.agents/skills/<skill>/`，setup 会先执行
@@ -75,9 +84,9 @@ Provider 由 npm 包分发，但包本身无需暴露 CLI 或安装脚本。setu
 可创建的浏览器类型名称及其表单参数：
 ```bash
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta provider install @example/mearl-provider-device
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta provider update example-device
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta provider uninstall example-device
+npx @mearl/setup@beta provider install @example/mearl-provider-device
+npx @mearl/setup@beta provider update example-device
+npx @mearl/setup@beta provider uninstall example-device
 ```
 安装参数接受包名、版本或 dist-tag；更新和卸载可使用 providerId 或完整包名。核心 @mearl 包固定使用公共 npm registry；其余 scope 沿用调用方的包管理器配置，组织 registry 由能力安装引导提供。安装沿用启动 setup 的包管理器，
@@ -88,21 +97,20 @@ npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta provider unin
 ## 行为
 - Mearl 自有 npm 包的安装和更新固定使用 `https://registry.npmjs.org/`，与最新版本查询使用同一来源；第三方包沿用当前包管理器的源配置。
-- `install` 可以省略；直接执行 `npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta` 等同于 `npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta install`。
-  以选项开头时也默认安装，例如 `npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta --cloud --yes`。
+- `install` 可以省略；直接执行 `npx @mearl/setup@beta` 等同于 `npx @mearl/setup@beta install`。
+  以选项开头时也默认安装，例如 `npx @mearl/setup@beta --cloud --yes`。
 - `install` 未指定环境时默认 `--local`。
 - `-h` / `--help` 显示帮助，`-v` / `--version` 显示 setup 版本。
 - `update` 和 `uninstall` 未指定环境时，从当前 `PATH` 中的
   `mearl-native-host`、`mearl-cloud-server`、`mearl-mcp-server` 自动检测，可同时处理
   多个已安装环境。
 - `--local`、`--cloud` 与 `--mcp` 可以组合，显式传入时只处理选中的环境；
-  `--qoder-cloud` 选择相同的 cloud 环境并记录 Qoder 配对模式，不能与 `--cloud` 同时使用。
+  `--cloud-mode <id>` 同时选择 cloud 环境，模式实现必须来自已安装能力。
 - 已有环境沿用其原包管理器和全局安装前缀；首次安装沿用启动 setup 的包管理器。
 - `uninstall` 也识别 `npm link` 或 `dev:link` 注册到 npm 全局目录的开发软链，
   通过原 npm 前缀移除包与命令链接，保留仓库源码。安装和更新的自动检测仅处理常规全局安装。
 - cloud 环境统一管理 `@mearl/cloud-server` 与 `@mearl/client`：WebSocket 模式首次安装后
-  启动 Server，更新后仅在 Server 原本运行时重启；Qoder 模式由相同的 `start` 命令生成
-  新配对但不起服务；卸载前均调用 `stop`。
+  启动 Server，更新后仅在 Server 原本运行时重启；其他 mode 由安装的 `cloud.server.<id>` 处理；卸载前均调用 `stop`。
 - local/cloud 共用一份 `@mearl/client`；组合安装只处理一次，卸载单个环境时若另一个环境仍在使用则保留。
 - 从 2.5.x 更新 cloud 环境时会先卸载旧 `@mearl/cloud-client`，避免它遗留的 `mearl` bin 与统一 client 冲突。
 - local/cloud 共用的全局 mearl skill 通过 `skills` 的 JSON 清单定位，只处理一次。
@@ -121,7 +129,7 @@ npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta provider unin
   CDP 标签 ID 计数也保留，防止旧请求命中新标签。
 - `--mcp` 的客户端配置和清理由 `@mearl/mcp-server` 自己的命令完成。
 - 默认的 `install` / `update` 不处理浏览器扩展。`extension` 是独立命令：从
-  `https://github.com/F-loat/mearl/releases/download/v3.0.0-beta.1/` 读取同版本 beta 扩展发行元数据（正式 setup 使用 `releases/latest/download/`）并下载对应的 `mearl-chrome-v*.zip`，原子解压到
+  `https://github.com/mearlhq/mearl/releases/download/v<version>/` 读取同版本 beta 扩展发行元数据（正式 setup 使用 `releases/latest/download/`）并下载对应的 `mearl-chrome-v*.zip`，原子解压到
   `~/.mearl/chrome-extension`。首次安装通过浏览器级 CDP 的 `Extensions.loadUnpacked`
   加载；后续更新由 `mearl check --local --json` 确认当前扩展仍来自 setup 管理目录后，直接替换
   文件并通过 Native Host 触发扩展 reload。固定目录和 manifest 中的 `key` 保证扩展 ID
@@ -137,19 +145,19 @@ npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta provider unin
 ## 安装或更新浏览器扩展
 ```bash
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta extension
+npx @mearl/setup@beta extension
 ```
 首次使用时可一次安装完整的本地浏览器环境：
 ```bash
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta extension --full
+npx @mearl/setup@beta extension --full
 ```
 首次安装、旧版 setup 扩展首次迁移，或 Native Host reload 不可用时才需要 CDP。如果
 Chrome 尚未开放 CDP，交互命令会提示打开
 `chrome://inspect/#remote-debugging`、启用远程调试并允许连接，然后等待安装完成。面向人的
-安装指引不要添加 `--yes`。无 TTY 环境使用 `npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta extension --yes`；它只尝试
+安装指引不要添加 `--yes`。无 TTY 环境使用 `npx @mearl/setup@beta extension --yes`；它只尝试
 一次，CDP 不可用时立即中断。无法确认 setup 管理来源且 CDP 不可用时不会下载或修改插件
 目录，打开 CDP 后重新执行同一命令即可。Chrome 版本过低、缺少扩展安装所需的 CDP 方法时，
 命令会中断并提示升级 Chrome。
@@ -179,7 +187,7 @@ DevTools 面板的设置按钮会显示红点，快捷设置中提供“立即
 自动更新不会降级较新的 Host，也不会改动 cloud、MCP 或独立安装的 Mearl Skill。
 目标 npm 版本尚未发布、网络不可用或更新失败时，旧 Host 会继续运行；下一次扩展后台
-生命周期可重新尝试，也可手动执行 `npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta update --local`。
+生命周期可重新尝试，也可手动执行 `npx @mearl/setup@beta update --local`。
 ## 人工与 Agent 使用
@@ -194,41 +202,41 @@ DevTools 面板的设置按钮会显示红点，快捷设置中提供“立即
 ```bash
 # 默认安装本地浏览器环境
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup
+npx @mearl/setup
 # 与上一条等价
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta install
+npx @mearl/setup@beta install
 # Agent / CI 无交互安装
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta --yes
+npx @mearl/setup@beta --yes
 # 安装云端 Agent 环境
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta --cloud
+npx @mearl/setup@beta --cloud
 # 同一台机器同时作为本地浏览器宿主和云端 Agent
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta --local --cloud
+npx @mearl/setup@beta --local --cloud
 # 自动更新当前 PATH 中检测到的全部 Mearl 环境
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta update
+npx @mearl/setup@beta update
 # 独立安装或更新到最新浏览器扩展
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta extension
+npx @mearl/setup@beta extension
 # 安装完整本地环境（client、Native Host、Skill 和扩展）
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta extension --full
+npx @mearl/setup@beta extension --full
 # 只卸载本地环境
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta uninstall --local
+npx @mearl/setup@beta uninstall --local
 # 自动检测并无交互卸载
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta uninstall --yes
+npx @mearl/setup@beta uninstall --yes
 # 卸载环境，并清理全部 CLI 插件与 Provider
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta uninstall --full
+npx @mearl/setup@beta uninstall --full
 # 安装可选浏览器 Provider
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta provider install @example/mearl-provider-device
-npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta provider install @example/mearl-provider-cloud
+npx @mearl/setup@beta provider install @example/mearl-provider-device
+npx @mearl/setup@beta provider install @example/mearl-provider-cloud
 ```
 原有 Mearl 环境包的 npm/npx 安装方式和 CLI 保持可用；setup 是统一的便利入口。
@@ -237,6 +245,12 @@ npx --@mearl:registry=https://registry.npmjs.org @mearl/setup@beta provider inst
 `mearl-setup preset apply <source-url-or-path>` 准备确切资源、激活本机 Node 选择，并向兼容扩展同步同一批浏览器资源；`preset update` 保留用户覆盖，`preset status` 只读检查实际就绪状态。退出码 3 表示存在待同步/安装组件。完整扩展、默认设置、Skills/Provider 和网页一键安装使用同一实际状态核验，见 [本机安装合同](../../docs/preset-installation.md)。
-普通 install/update 在替换包前保存选中 preset 的确切资源和期望选择，运行时初始化后再同步宿主和安装 Skills；`extension --full` 也在替换扩展前完成准备。已有本机 preset 优先保留，显式 `--preset` 可更新或修复资源；检测到已安装包为 3.0 以前版本且尚无选择时，读取公共部署目录的 `legacyPreset`。配置或资源不可用会在包变更前停止，不回退到无内部能力的安装。部分升级后的重试使用已保存安装记录，即使包版本已变为 3.x 也不重新下载。维护旧版本线和卸载不自动迁移。
+普通 install/update 在替换包前保存选中 preset 的确切资源和期望选择，运行时初始化后再同步宿主和安装 Skills；`extension --full` 也在替换扩展前完成准备。已有本机 preset 优先保留，显式 `--preset` 可更新或修复资源。配置或资源不可用会在包变更前停止，不回退到无内部能力的安装。部分升级后的重试使用已保存安装记录，即使包版本已变为 3.x 也不重新下载。卸载不准备或安装 preset。
 默认目录为公共站点的 `installation.json`，可通过 `MEARL_INSTALLATION_CONFIG_URL` 指定其他 HTTPS 目录（本地验证允许回环 HTTP）。核心不包含组织 ID 或私有来源；目录沿用网页安装的校验合同。本机与浏览器未全部确认时仍报告 pending，准备成功不表示已发行或已完成真实企业授权验收。
+## 浏览器 preset 与发行入口
+主动执行 setup 时，先沿用本机已选 preset；本机未选择时，在运行时初始化后、安装 Skill 前采用已连接浏览器的受信 preset。显式 `--preset <source>` 优先。多个浏览器的选择不同、来源不受信或状态读取失败时要求显式选择。首次连接最多等待约一分钟；浏览器关闭时只安装基础环境并说明重试方式。普通连接和后台核心更新不会自动安装首次本机 preset。
+发行包可设置本机进程环境变量 `MEARL_SETUP_DEFAULT_PRESET` 提供默认清单来源；默认值仅在两端均无选择时生效，插件、Provider、卸载等子命令保持原行为。安装与状态核验仍由公共安装器负责。

package/dist/browserExtension.js CHANGED Viewed

@@ -6,15 +6,15 @@ import path from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
 import { runUnifiedCheck } from '@mearl/client/check';
 import { CLIENT_VERSION, invoke as invokeLocalMearl } from '@mearl/client/local';
-import extractZip from 'extract-zip';
+import AdmZip from 'adm-zip';
 import WebSocket from 'ws';
 import { compareMearlReleaseVersions, isMearlReleaseVersion } from './version.js';
 export const MEARL_EXTENSION_DOWNLOAD_PAGE = SETUP_VERSION.includes('-beta.')
-    ? `https://github.com/F-loat/mearl/releases/tag/v${SETUP_VERSION}`
-    : 'https://github.com/F-loat/mearl/releases/latest';
+    ? `https://github.com/mearlhq/mearl/releases/tag/v${SETUP_VERSION}`
+    : 'https://github.com/mearlhq/mearl/releases/latest';
 export const MEARL_EXTENSION_REMOTE_CONFIG_URL = SETUP_VERSION.includes('-beta.')
-    ? `https://github.com/F-loat/mearl/releases/download/v${SETUP_VERSION}/config.json`
-    : 'https://github.com/F-loat/mearl/releases/latest/download/config.json';
+    ? `https://github.com/mearlhq/mearl/releases/download/v${SETUP_VERSION}/config.json`
+    : 'https://github.com/mearlhq/mearl/releases/latest/download/config.json';
 export const MEARL_EXTENSION_DIRECTORY_NAME = 'chrome-extension';
 export const MEARL_EXTENSION_ID = 'aoehhjnofngknnjefamjbplchbolghkm';
 export const MEARL_EXTENSION_SETUP_MARKER = '.mearl-setup.json';
@@ -52,7 +52,7 @@ export function extensionArchiveUrl(version) {
     if (!isMearlReleaseVersion(version)) {
         throw new Error(`Invalid Mearl browser extension version: ${version}`);
     }
-    return `https://github.com/F-loat/mearl/releases/download/v${version}/mearl-chrome-v${version}.zip`;
+    return `https://github.com/mearlhq/mearl/releases/download/v${version}/mearl-chrome-v${version}.zip`;
 }
 function validateExtensionRelease(release) {
     if (!isMearlReleaseVersion(release.version)) {
@@ -414,6 +414,22 @@ function readExtensionManifest(directory) {
     }
     return parsed;
 }
+async function extractExtensionArchive(archivePath, destination) {
+    const archive = new AdmZip(archivePath);
+    // Extension releases contain ordinary files and directories, never symlinks.
+    // Validate every entry before writing anything into the fresh staging directory.
+    for (const entry of archive.getEntries()) {
+        const name = entry.entryName;
+        const type = (entry.header.attr >>> 16) & 0o170000;
+        if (name.includes('\\') || name.includes('\0') ||
+            path.posix.isAbsolute(name) || path.win32.isAbsolute(name) ||
+            name.split('/').some(part => part === '..' || part === '.') ||
+            (type !== 0 && type !== 0o100000 && type !== 0o040000)) {
+            throw new Error('Extension archive contains an unsafe entry');
+        }
+    }
+    await archive.extractAllToAsync(destination, false);
+}
 async function downloadAndReplaceExtension(releaseInput, targetDirectory, fetchImpl, extractArchive) {
     const release = validateExtensionRelease(releaseInput);
     const parentDirectory = path.dirname(targetDirectory);
@@ -462,7 +478,7 @@ export async function updateSetupManagedBrowserExtensionFiles(options, dependenc
     }
     const fetchImpl = dependencies.fetch ?? fetch;
     const extractArchive = dependencies.extractArchive ??
-        ((archivePath, destination) => extractZip(archivePath, { dir: destination }));
+        extractExtensionArchive;
     const release = await downloadAndReplaceExtension(options.release, targetDirectory, fetchImpl, extractArchive);
     return { ...release, path: targetDirectory };
 }
@@ -470,7 +486,7 @@ export async function installMearlBrowserExtension(options = {}, dependencies =
     const connectCdp = dependencies.connectCdp ?? connectBrowserExtensionViaCdp;
     const fetchImpl = dependencies.fetch ?? fetch;
     const extractArchive = dependencies.extractArchive ??
-        ((archivePath, destination) => extractZip(archivePath, { dir: destination }));
+        extractExtensionArchive;
     const loadUnpacked = dependencies.loadUnpacked ?? loadUnpackedViaCdp;
     const inspectInstallation = dependencies.inspectInstallation ?? inspectMearlExtensionViaCdp;
     const inspectInstalled = dependencies.inspectInstalled ?? inspectSetupManagedExtension;

package/dist/browserPreset.d.ts ADDED Viewed

@@ -0,0 +1,20 @@
+import { invokeLocalHost, listLiveBrowsers } from '@mearl/client/local';
+import { loadInstallationConfig } from '@mearl/preset/installation';
+import { createNodePresetLoader } from './preset.js';
+import type { StagedPresetInstallation } from './preset.js';
+interface Options {
+    env?: NodeJS.ProcessEnv;
+    waitMs?: number;
+    writeLine?: (line: string) => void;
+}
+interface Dependencies {
+    browsers?: typeof listLiveBrowsers;
+    invoke?: typeof invokeLocalHost;
+    configuration?: () => ReturnType<typeof loadInstallationConfig>;
+    load?: ReturnType<typeof createNodePresetLoader>;
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+}
+/** Explicit setup may complete a trusted browser selection before installing any Skills. */
+export declare function prepareBrowserSetupPreset(options?: Options, dependencies?: Dependencies): Promise<StagedPresetInstallation | undefined>;
+export {};

package/dist/browserPreset.js ADDED Viewed

@@ -0,0 +1,82 @@
+import { invokeLocalHost, listLiveBrowsers } from '@mearl/client/local';
+import { installationOriginCovered, loadInstallationConfig, matchesInstallationOrigin, trustedInstallationPreset } from '@mearl/preset/installation';
+import { 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;
+    const directory = env.MEARL_CAPABILITY_DIR;
+    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));
+        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 });
+            }
+            catch {
+                throw new Error(`Cannot read preset from ${browser.browserId}. Reconnect the extension and retry setup, or use --preset <source>.`);
+            }
+            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)
+                return [];
+            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)
+        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>.');
+    const trusted = trustedInstallationPreset(await configuration(), first.presetId, first.presetSource);
+    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 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');
+            return load(source, resourceOptions);
+        } });
+    options.writeLine?.(`Using the browser's trusted preset: ${first.presetId}`);
+    return installer.stage(first.presetSource, {
+        expectedId: first.presetId, expectedRevision: null, signal: AbortSignal.timeout(120_000),
+        validatePrepared: async (prepared) => {
+            if (prepared.preset.permissions.origins.some(origin => !installationOriginCovered(origin, trusted.origins)))
+                throw new Error('Browser preset permissions exceed the trusted installation catalog');
+        },
+        confirm: async () => {
+            if (JSON.stringify(trustedInstallationPreset(await configuration(), first.presetId, first.presetSource)) !== JSON.stringify(trusted))
+                throw new Error('Browser preset trust changed during setup');
+            const latest = await read();
+            if (!latest || latest.length !== accepted.length || accepted.some(value => !latest.some(other => value.browserId === other.browserId && value.presetId === other.presetId && value.presetSource === other.presetSource && value.browserRevision === other.browserRevision)))
+                throw new Error('The browser preset changed during setup. Retry or use --preset <source>.');
+        },
+    });
+}

package/dist/cli.d.ts CHANGED Viewed

@@ -5,16 +5,17 @@ import type { MearlProfile } from './profiles.js';
 import { ensureOfficialPlugin, installPlugins, setupPlugin, uninstallPlugin } from './plugin.js';
 import { installProviderPackage, uninstallProviderPackage, updateProviderPackage } from './provider.js';
 import { runPresetCommand } from './preset.js';
-import { prepareSetupPreset } from './presetUpgrade.js';
+import { prepareSetupPreset } from './setupPreset.js';
 export { SETUP_VERSION } from './setupVersion.js';
 interface ParsedArgs {
-    cloudMode?: 'websocket' | 'qoder';
+    cloudMode?: string;
     force?: boolean;
     full?: boolean;
     help: boolean;
     operation?: MearlLifecycleOperation | 'extension' | 'plugin' | 'provider' | 'preset';
-    presetCommand?: 'apply' | 'update' | 'status';
+    presetCommand?: 'apply' | 'update' | 'status' | 'repair';
     presetSource?: string;
+    presetReplaceSkills?: string[];
     pluginName?: string;
     pluginPath?: string;
     pluginInstallArgs?: string[];

package/dist/cli.js CHANGED Viewed

@@ -6,7 +6,7 @@ import { isMearlReleaseLine } from './version.js';
 import { ensureOfficialPlugin, installPlugins, setupPlugin, uninstallPlugin } from './plugin.js';
 import { installProviderPackage, uninstallProviderPackage, updateProviderPackage, } from './provider.js';
 import { runPresetCommand } from './preset.js';
-import { prepareSetupPreset } from './presetUpgrade.js';
+import { prepareSetupPreset } from './setupPreset.js';
 import { SETUP_VERSION, SETUP_COMMAND } from './setupVersion.js';
 export { SETUP_VERSION } from './setupVersion.js';
 const baseParsedArgs = () => ({
@@ -26,11 +26,33 @@ function commanderError(error) {
 }
 export function parseSetupArgs(argv) {
     if (argv[0] === 'preset') {
+        if (argv[1] === 'repair') {
+            const command = new Command('preset repair')
+                .exitOverride()
+                .configureOutput({ writeErr: () => { }, writeOut: () => { } })
+                .allowExcessArguments(false)
+                .option('--replace-skill <name>', 'Replace the named Skill source or conflicting plugin registration', (name, previous) => [...previous, name], []);
+            try {
+                command.parse(argv.slice(2), { from: 'user' });
+            }
+            catch (error) {
+                if (error instanceof CommanderError) {
+                    if (error.code === 'commander.helpDisplayed')
+                        return { ...baseParsedArgs(), help: true };
+                    throw commanderError(error);
+                }
+                throw error;
+            }
+            const names = command.opts().replaceSkill;
+            if (names.length > 256 || new Set(names).size !== names.length || names.some(name => !/^[a-z][a-z0-9-]{0,79}$/.test(name)))
+                throw new Error('--replace-skill requires unique valid Skill names (up to 256)');
+            return { ...baseParsedArgs(), operation: 'preset', presetCommand: 'repair', ...(names.length ? { presetReplaceSkills: names } : {}) };
+        }
         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');
+        throw new Error('preset requires apply <source-url-or-path>, update, repair [--replace-skill <name>], or status');
     }
     if (argv[0] === 'provider') {
         const command = argv[1];
@@ -87,7 +109,7 @@ export function parseSetupArgs(argv) {
             .configureOutput({ writeErr: () => { }, writeOut: () => { } })
             .option('--local')
             .option('--cloud')
-            .option('--qoder-cloud')
+            .option('--cloud-mode <id>')
             .option('--mcp')
             .option('--target-line <major.minor.x>')
             .option('--skip-skill')
@@ -98,9 +120,8 @@ export function parseSetupArgs(argv) {
             command.option('--full');
         command.action(() => {
             const options = command.opts();
-            if (options.cloud && options.qoderCloud) {
-                throw new Error('--cloud and --qoder-cloud cannot be used together');
-            }
+            if (options.cloudMode !== undefined && !/^[a-z][a-z0-9-]{0,63}$/.test(options.cloudMode))
+                throw new Error('--cloud-mode requires a valid installed mode ID');
             if (options.targetLine && !isMearlReleaseLine(options.targetLine)) {
                 throw new Error('--target-line requires a valid Mearl release line such as 2.3.x');
             }
@@ -114,15 +135,15 @@ export function parseSetupArgs(argv) {
             const profiles = [];
             if (options.local)
                 profiles.push('local');
-            if (options.cloud || options.qoderCloud)
+            if (options.cloud || options.cloudMode)
                 profiles.push('cloud');
             if (options.mcp)
                 profiles.push('mcp');
             parsed = {
                 ...baseParsedArgs(),
                 operation,
-                ...(options.cloud || options.qoderCloud
-                    ? { cloudMode: options.qoderCloud ? 'qoder' : 'websocket' }
+                ...(options.cloud || options.cloudMode
+                    ? { cloudMode: options.cloudMode ?? 'websocket' }
                     : {}),
                 ...(profiles.length > 0 ? { profiles } : {}),
                 ...(options.full ? { full: true } : {}),
@@ -177,7 +198,7 @@ function printHelp() {
     const output = `Mearl Setup v${SETUP_VERSION}
 Usage:
-  npx --@mearl:registry=https://registry.npmjs.org @mearl/setup [command] [options]
+  npx @mearl/setup [command] [options]
 Environment commands:
   install [options]               Install an environment (default command; target: local)
@@ -187,6 +208,7 @@ Environment commands:
 Integration commands:
   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
   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
@@ -201,7 +223,7 @@ Browser extension:
 Environment options:
   --local                         Manage @mearl/native-host and @mearl/client
   --cloud                         Manage cloud packages in WebSocket server mode
-  --qoder-cloud                   Manage cloud packages in Qoder pairing mode
+  --cloud-mode <id>                Manage cloud packages using an installed 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
@@ -214,6 +236,9 @@ Extension options:
   --full                          Install the extension and complete local environment
   --force                         Replace an extension managed by another source
+Preset repair options:
+  --replace-skill <name>           Replace one Skill source or conflicting registration; repeat for more
 General options:
   --yes, -y                       Accept prompts and detected defaults
   --non-interactive               Alias for --yes, intended for Agents and CI
@@ -221,21 +246,24 @@ General options:
   --help, -h                      Show this help
 Examples:
-  npx --@mearl:registry=https://registry.npmjs.org @mearl/setup
-  npx --@mearl:registry=https://registry.npmjs.org @mearl/setup --cloud
-  npx --@mearl:registry=https://registry.npmjs.org @mearl/setup --local --cloud
-  npx --@mearl:registry=https://registry.npmjs.org @mearl/setup update
-  npx --@mearl:registry=https://registry.npmjs.org @mearl/setup uninstall --full
-  npx --@mearl:registry=https://registry.npmjs.org @mearl/setup plugin uninstall yuque
-  npx --@mearl:registry=https://registry.npmjs.org @mearl/setup provider install @example/mearl-provider-brow
-  npx --@mearl:registry=https://registry.npmjs.org @mearl/setup extension --full`;
-    console.log(output.replaceAll('npx --@mearl:registry=https://registry.npmjs.org @mearl/setup', SETUP_COMMAND));
+  npx @mearl/setup
+  npx @mearl/setup --cloud
+  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 preset repair --replace-skill example-skill
+  npx @mearl/setup extension --full`;
+    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);
+    const defaultPresetSource = process.env.MEARL_SETUP_DEFAULT_PRESET;
+    const configured = defaultPresetSource ? { ...options, defaultPresetSource } : options;
+    const ok = callback ? await lifecycle(configured, callback) : await lifecycle(configured);
     if (!ok)
         return 1;
     if (!preset) {
@@ -269,7 +297,10 @@ export async function main(argv = process.argv.slice(2), interactiveTerminal = p
     }
     if (parsed.operation === 'preset') {
         try {
-            const result = await (dependencies.runPreset ?? runPresetCommand)(parsed.presetCommand, parsed.presetSource);
+            const run = dependencies.runPreset ?? runPresetCommand;
+            const result = parsed.presetReplaceSkills
+                ? await run(parsed.presetCommand, parsed.presetSource, { replaceSkills: parsed.presetReplaceSkills })
+                : await run(parsed.presetCommand, parsed.presetSource);
             console.log(JSON.stringify(result, null, 2));
             return result.ready ? 0 : 3;
         }

package/dist/lifecycle.d.ts CHANGED Viewed

@@ -9,13 +9,16 @@ import { installManagedPlugins, uninstallManagedPlugins } from './managedPlugins
 import { uninstallPlugin } from './plugin.js';
 import { uninstallProviderPackage } from './provider.js';
 import { cleanupUninstalledRuntime } from './runtimeCleanup.js';
-import { prepareSetupPreset } from './presetUpgrade.js';
+import { prepareSetupPreset } from './setupPreset.js';
+import { prepareBrowserSetupPreset } from './browserPreset.js';
 import type { PresetInstallStatus } from './preset.js';
 export type MearlLifecycleOperation = 'install' | 'update' | 'uninstall';
 export interface MearlLifecycleOptions {
     presetSource?: string;
+    /** Distribution default used only when neither local nor browser selection exists. */
+    defaultPresetSource?: string;
     operation: MearlLifecycleOperation;
-    cloudMode?: 'websocket' | 'qoder';
+    cloudMode?: string;
     /** Uninstall every registered CLI plugin and Provider in addition to selected environments. */
     full?: boolean;
     /** @deprecated Use profiles when selecting one or more composable environments. */
@@ -27,6 +30,7 @@ export interface MearlLifecycleOptions {
     env?: NodeJS.ProcessEnv;
 }
 export interface MearlLifecycleDependencies {
+    prepareBrowserPreset?: typeof prepareBrowserSetupPreset;
     preparePreset?: typeof prepareSetupPreset;
     onPresetStatus?: (status: PresetInstallStatus) => void;
     /** Prepare the selected manager after packages are usable and before Skill operations. */

package/dist/lifecycle.js CHANGED Viewed

@@ -16,7 +16,8 @@ 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';
+import { prepareSetupPreset } from './setupPreset.js';
+import { prepareBrowserSetupPreset } from './browserPreset.js';
 const LEGACY_CLOUD_CLIENT = '@mearl/cloud-client';
 const UNIFIED_CLIENT = '@mearl/client';
 const PROFILE_ORDER = ['local', 'cloud', 'mcp'];
@@ -135,12 +136,12 @@ async function runHook(profile, operation, detected, runner, existsSync, env, wr
                 return false;
             }
             const running = /\[CloudServer\]\s+Status:\s+running\b/.test(status.stdout);
-            const qoderMode = cloudMode === 'qoder' || /\[CloudServer\]\s+Mode:\s+qoder\b/.test(status.stdout);
-            if (operation === 'update' && !running && !qoderMode) {
+            const pluginMode = Boolean(cloudMode && cloudMode !== 'websocket') || /\[CloudServer\]\s+Mode:\s+(?!websocket\b)\S+/.test(status.stdout);
+            if (operation === 'update' && !running && !pluginMode) {
                 writeLine('Hook: cloud update skipped because cloud-server is not running.');
                 return true;
             }
-            args = [running && !qoderMode ? 'restart' : 'start'];
+            args = [running && !pluginMode ? 'restart' : 'start'];
         }
     }
     else {
@@ -236,7 +237,7 @@ export async function runMearlLifecycle(options, dependencies = {}) {
         writeLine('No installed Mearl environment was detected on the current PATH.');
         if (options.operation === 'uninstall')
             return true;
-        writeLine('Run: npx --@mearl:registry=https://registry.npmjs.org @mearl/setup');
+        writeLine('Run: npx @mearl/setup');
         return false;
     }
     if (options.operation === 'update') {
@@ -281,16 +282,13 @@ export async function runMearlLifecycle(options, dependencies = {}) {
         ? detectPackage(UNIFIED_CLIENT, ['mearl'], packageDetectionOptions)
         : null;
     const detectedClient = detectedClientCandidate?.packageName === UNIFIED_CLIENT ? detectedClientCandidate : null;
+    const preparesPreset = options.operation !== 'uninstall' && !dependencies.prepareSkills && (!options.targetLine || Number(options.targetLine.split('.')[0]) >= 3);
+    const selectsInitialPreset = preparesPreset && !options.skipSkill && !env.MEARL_AUTO_UPDATE_CLIENT_ROOT && !env.MEARL_AUTO_UPDATE_PROFILES;
     let stagedPreset;
-    if (options.operation !== 'uninstall' && (options.presetSource || !options.targetLine || Number(options.targetLine.split('.')[0]) >= 3) && !dependencies.prepareSkills) {
+    if (preparesPreset || (options.operation !== 'uninstall' && options.presetSource && !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) {
@@ -422,6 +420,24 @@ 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 });
+        }
+        catch (error) {
+            writeLine(`Browser preset: ${error instanceof Error ? error.message : String(error)}`);
+            packagesOk = false;
+        }
+    }
+    if (packagesOk && selectsInitialPreset && !stagedPreset && options.defaultPresetSource) {
+        try {
+            stagedPreset = await (dependencies.preparePreset ?? prepareSetupPreset)({ fallbackSource: options.defaultPresetSource, env });
+        }
+        catch (error) {
+            writeLine(`Default preset: ${error instanceof Error ? error.message : String(error)}`);
+            packagesOk = false;
+        }
+    }
     if (packagesOk && options.operation !== 'uninstall' && (stagedPreset || dependencies.prepareSkills)) {
         try {
             if (stagedPreset) {

package/dist/preset.d.ts CHANGED Viewed

@@ -1,7 +1,10 @@
 import { invoke } from '@mearl/client/local';
 import { type JsonObject } from '@mearl/preset';
-import { type BundleLoader } from '@mearl/preset/bundles';
+import { type BundleLoader, type PreparedPreset } from '@mearl/preset/bundles';
 import { PresetInstallationStore } from './presetStore.js';
+export declare const MEARL_INSTALLATION_CONFIG_URL: string;
+/** Runtime overrides apply to this local process, never to browser-supplied install requests. */
+export declare function resolveInstallationConfigUrl(value?: string | undefined, allowLoopback?: boolean): URL;
 export { claimPresetInstallation } from './presetInstallationLease.js';
 export { PresetInstallationStore, presetSelectionRevision } from './presetStore.js';
 export type { PresetInstallReceipt } from './presetStore.js';
@@ -59,8 +62,9 @@ export interface PresetInstallerOptions {
     invoke?: typeof invoke;
 }
 export interface PresetApplyOptions {
+    validatePrepared?: (prepared: PreparedPreset) => Promise<void>;
+    skipUnchanged?: boolean;
     overrides?: JsonObject;
-    nodeConfig?: Record<string, JsonObject>;
     signal?: AbortSignal;
     expectedRevision?: string | null;
     expectedId?: string;
@@ -87,8 +91,15 @@ export declare class PresetInstaller {
     /** Save exact resources and desired selection; activate once after runtime setup, then retry via resume. */
     stage(source: string, options?: PresetApplyOptions): Promise<StagedPresetInstallation>;
     apply(source: string, options?: PresetApplyOptions): Promise<PresetInstallStatus>;
-    update(): Promise<PresetInstallStatus>;
-    resume(expectedRevision: string): Promise<PresetInstallStatus>;
+    update(options?: Pick<PresetApplyOptions, 'validatePrepared' | 'skipUnchanged' | 'signal'>): Promise<PresetInstallStatus>;
+    resume(expectedRevision: string, options?: {
+        replaceSkills?: readonly string[];
+    }): Promise<PresetInstallStatus>;
+    repair(options?: {
+        replaceSkills?: readonly string[];
+    }): Promise<PresetInstallStatus>;
     configure(value: JsonObject): Promise<PresetInstallStatus>;
 }
-export declare function runPresetCommand(command: 'apply' | 'update' | 'status', source?: string): Promise<PresetInstallStatus>;
+export declare function runPresetCommand(command: 'apply' | 'update' | 'status' | 'repair', source?: string, options?: {
+    replaceSkills?: readonly string[];
+}): Promise<PresetInstallStatus>;

package/dist/preset.js CHANGED Viewed

@@ -1,11 +1,21 @@
 import { lstat, open } from 'node:fs/promises';
 import { constants } from 'node:fs';
+import { createRequire } from 'node:module';
 import { resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { invoke, invokeLocalHost, listLiveBrowsers, SOCKET_PATH } from '@mearl/client/local';
 import { mergePresetDefaults } from '@mearl/preset';
 import { BundleError, createBundleFetchLoader, preparePreset } from '@mearl/preset/bundles';
 import { PresetInstallationStore, presetSelectionRevision } from './presetStore.js';
+const installationSite = createRequire(import.meta.url)('@mearl/preset/installation-site.json');
+export const MEARL_INSTALLATION_CONFIG_URL = new URL('installation.json', installationSite.url).href;
+/** Runtime overrides apply to this local process, never to browser-supplied install requests. */
+export function resolveInstallationConfigUrl(value = process.env.MEARL_INSTALLATION_CONFIG_URL, allowLoopback = false) {
+    const url = new URL(value || MEARL_INSTALLATION_CONFIG_URL);
+    if (url.username || url.password || url.hash || (url.protocol !== 'https:' && !(allowLoopback && url.protocol === 'http:' && ['127.0.0.1', 'localhost', '[::1]'].includes(url.hostname))))
+        throw new Error('Invalid installation configuration URL');
+    return url;
+}
 export { claimPresetInstallation } from './presetInstallationLease.js';
 export { PresetInstallationStore, presetSelectionRevision } from './presetStore.js';
 export { PresetBrowserTransfer } from './presetBrowserTransfer.js';
@@ -102,12 +112,12 @@ export class PresetInstaller {
             }
         }));
     }
-    async componentStatus(install, receipt) {
+    async componentStatus(install, receipt, replaceSkills) {
         const target = (this.options.hosts?.() ?? localHosts(install))[0];
         if (!target)
             return {};
         try {
-            const result = await this.invokeHost(install ? 'preset_components_install' : 'preset_components_status', { installationRevision: receipt.revision }, target, install ? 900 : 15, install);
+            const result = await this.invokeHost(install ? 'preset_components_install' : 'preset_components_status', { installationRevision: receipt.revision, ...(install && replaceSkills?.length ? { replaceSkills } : {}) }, target, install ? 900 : 15, install);
             if (result?.installationRevision !== receipt.revision || result?.nodeRevision !== receipt.nodeRevision || !Array.isArray(result?.components))
                 throw new Error('Component installation host requires an update');
             if (result.catalogReady !== undefined && typeof result.catalogReady !== 'boolean')
@@ -141,7 +151,7 @@ export class PresetInstaller {
         result.nodeRevision = receipt.nodeRevision;
         result.browserRevision = receipt.browserRevision;
         result.browserSyncRequired = receipt.browserSyncRequired === true;
-        result.localComponentCount = Object.values(preset.packages).filter(entry => entry.enabled !== false && entry.runtimes?.includes('node')).length
+        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);
         const nodeReady = result.hosts.length > 0 && result.hosts.every(host => host.state === 'active');
@@ -151,12 +161,12 @@ export class PresetInstaller {
         for (const [id, entry] of Object.entries(preset.packages)) {
             if (entry.enabled === false)
                 continue;
-            for (const runtime of entry.runtimes ?? []) {
+            for (const runtime of entry.targets ?? []) {
                 if (runtime === 'browser') {
                     if (!browserReady)
                         result.pending.push({ kind: 'packages', id, runtime, reason: 'BROWSER_SYNC_REQUIRED' });
                 }
-                else if (!receipt.managedModules.includes(id))
+                else if (!receipt.managedModules.includes(id) && Object.keys(current.prepared.bundles.find(bundle => bundle.manifest.id === id)?.manifest.contributions?.nodeRuntimes ?? {}).length)
                     result.pending.push({ kind: 'packages', id, runtime, reason: 'NODE_HOST_NOT_SUPPORTED' });
                 else if (!nodeReady)
                     result.pending.push({ kind: 'packages', id, runtime, reason: 'HOST_SYNC_REQUIRED' });
@@ -186,7 +196,7 @@ export class PresetInstaller {
         result.ready = result.pending.length === 0;
         return result;
     }
-    async synchronize(receipt, previousRevision) {
+    async synchronize(receipt, previousRevision, replaceSkills) {
         const hosts = await this.hostStatus(true, receipt.nodeRevision, receipt.revision);
         const rejection = hosts.find(host => host.state === 'rejected');
         if (rejection) {
@@ -207,7 +217,7 @@ export class PresetInstaller {
         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) : {};
+        const components = hasExternal || installed.activation?.bindings['plugins.catalog'] ? await this.componentStatus(true, receipt, replaceSkills) : {};
         const status = await this.status();
         if (components.error)
             status.warnings.push(`Component installation failed; completed assets retained for retry: ${components.error}`);
@@ -225,6 +235,20 @@ export class PresetInstaller {
         const prepared = await preparePreset(sourceUrl(source), { mearlApiVersion: this.store.mearlApiVersion, load: this.options.load ?? createNodePresetLoader(), signal: options.signal });
         if (options.expectedId !== undefined && prepared.preset.id !== options.expectedId)
             throw new BundleError('BUNDLE_INVALID', 'The preset identity differs from the accepted installation');
+        await options.validatePrepared?.(prepared);
+        if (options.skipUnchanged) {
+            const current = await this.store.current();
+            if (presetSelectionRevision(current) !== expectedRevision)
+                throw new BundleError('BUNDLE_CONFLICT', 'The installed preset changed during update');
+            if (current.receipt && current.prepared?.snapshot.revision === prepared.snapshot.revision) {
+                return { revision: current.receipt.revision, activate: async () => {
+                        const status = await this.status();
+                        if (status.revision !== expectedRevision)
+                            throw new BundleError('BUNDLE_CONFLICT', 'The installed preset changed during update');
+                        return status.ready ? status : this.resume(current.receipt.revision);
+                    } };
+            }
+        }
         const receipt = await this.store.apply(prepared, { ...options, expectedRevision });
         let activated = false;
         return { revision: receipt.revision, activate: async () => {
@@ -239,7 +263,7 @@ export class PresetInstaller {
     }
     /** Save exact resources and desired selection; activate once after runtime setup, then retry via resume. */
     async stage(source, options = {}) {
-        const accepted = { ...options, ...(options.overrides === undefined ? {} : { overrides: mergePresetDefaults({}, options.overrides) }), ...(options.nodeConfig === undefined ? {} : { nodeConfig: mergePresetDefaults({}, options.nodeConfig) }) };
+        const accepted = { ...options, ...(options.overrides === undefined ? {} : { overrides: mergePresetDefaults({}, options.overrides) }) };
         const current = await this.store.current({ verifyResources: false });
         const revision = presetSelectionRevision(current);
         if (accepted.expectedRevision !== undefined && accepted.expectedRevision !== revision)
@@ -249,17 +273,26 @@ export class PresetInstaller {
     async apply(source, options = {}) {
         return (await this.stage(source, options)).activate();
     }
-    async update() {
+    async update(options = {}) {
         const current = await this.store.current({ verifyResources: false });
         if (!current.receipt)
             throw new Error('No preset is installed');
-        return this.apply(current.receipt.snapshot.source, { expectedRevision: presetSelectionRevision(current) });
+        return this.apply(current.receipt.snapshot.source, { ...options, expectedRevision: presetSelectionRevision(current) });
     }
-    async resume(expectedRevision) {
+    async resume(expectedRevision, options = {}) {
         const current = await this.store.current();
         if (!current.receipt || current.receipt.revision !== expectedRevision)
             throw new BundleError('BUNDLE_CONFLICT', 'The installed preset changed before resuming');
-        return this.synchronize(current.receipt, expectedRevision);
+        const names = options.replaceSkills;
+        if (names !== undefined && (!Array.isArray(names) || !names.length || names.length > 256 || new Set(names).size !== names.length || names.some(name => typeof name !== 'string' || !/^[a-z][a-z0-9-]{0,79}$/.test(name) || !current.preset || !Object.hasOwn(current.preset.skills, name) || current.preset.skills[name].enabled === false)))
+            throw new Error('Invalid Skill replacement selection');
+        return this.synchronize(current.receipt, expectedRevision, options.replaceSkills);
+    }
+    async repair(options = {}) {
+        const current = await this.store.current({ verifyResources: false });
+        if (!current.receipt)
+            throw new Error('No preset is installed');
+        return this.resume(current.receipt.revision, options);
     }
     async configure(value) {
         const current = await this.store.current();
@@ -269,7 +302,11 @@ export class PresetInstaller {
         return this.synchronize(receipt, presetSelectionRevision(current));
     }
 }
-export async function runPresetCommand(command, source) {
+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();
+    if (command === 'repair')
+        return installer.repair(options);
     return command === 'status' ? installer.status() : command === 'update' ? installer.update() : installer.apply(source);
 }

package/dist/presetStore.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import { type JsonObject, type NodeCapabilityActivation, type ResolvedPreset } from '@mearl/preset';
+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;
@@ -9,13 +9,12 @@ export interface PresetInstallReceipt {
     managedModules: string[];
     nodeSyncRequired: boolean;
     browserSyncRequired?: boolean;
-    nodeConfig: Record<string, JsonObject>;
     overrides: JsonObject;
     revision: string;
 }
 interface SelectionState {
     rawHash: string | null;
-    activation?: NodeCapabilityActivation;
+    activation?: CapabilityActivation;
     receipt?: PresetInstallReceipt;
     prepared?: PreparedPreset;
     preset?: ResolvedPreset;
@@ -36,7 +35,6 @@ export declare class PresetInstallationStore {
     apply(input: Pick<PreparedPreset, 'snapshot' | 'bundles'>, options: {
         expectedRevision: string | null;
         overrides?: JsonObject;
-        nodeConfig?: Record<string, JsonObject>;
         signal?: AbortSignal;
         confirm?: () => Promise<void>;
     }): Promise<PresetInstallReceipt>;

package/dist/presetStore.js CHANGED Viewed

@@ -3,13 +3,13 @@ import { constants, closeSync, fstatSync, lstatSync, linkSync, mkdirSync, openSy
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { withRecordLock } from '@mearl/daemon-core';
-import { mergePresetDefaults, prepareNodeBundleSnapshot, prepareNodeCapabilitySnapshot, verifyNodeCapabilityActivation, validateNodeModuleConfig, resolvePresetModuleConfig, MAX_NODE_SELECTION_BYTES } from '@mearl/preset';
+import { mergePresetDefaults, prepareNodeBundleSnapshot, prepareCapabilitySnapshot, verifyCapabilityActivation, resolveCapabilityConfig, MAX_CAPABILITY_SELECTION_BYTES } from '@mearl/preset';
 import { BundleError, MAX_BROWSER_STORAGE_BYTES, presetRequiresBrowser, validateBundleManifest, verifyPreset, verifyBrowserPreset, verifyPreparedPreset } from '@mearl/preset/bundles';
 const digest = (bytes) => createHash('sha256').update(bytes).digest('hex');
 const hashPattern = /^[a-f0-9]{64}$/;
 const MAX_RECEIPT_BYTES = 16 * 1024 * 1024;
 const MAX_OVERRIDES_BYTES = 262_144;
-const POINTER_BYTES = MAX_NODE_SELECTION_BYTES + 128;
+const POINTER_BYTES = MAX_CAPABILITY_SELECTION_BYTES + 128;
 function readBounded(file, limit) {
     const before = lstatSync(file);
     if (!before.isFile() || before.isSymbolicLink() || before.size > limit)
@@ -84,7 +84,7 @@ export class PresetInstallationStore {
         if (!raw)
             return { rawHash: null };
         const rawHash = digest(raw);
-        const activation = await verifyNodeCapabilityActivation(JSON.parse(raw.toString('utf8')));
+        const activation = await verifyCapabilityActivation(JSON.parse(raw.toString('utf8')));
         if (!activation.installationRevision)
             return { rawHash, activation };
         const captured = withRecordLock(this.pointer, () => {
@@ -93,13 +93,12 @@ export class PresetInstallationStore {
             const receipt = JSON.parse(receiptBytes.toString('utf8'));
             const { revision: receiptRevision, ...data } = receipt;
             if (receiptRevision !== activation.installationRevision || digest(JSON.stringify(data)) !== receiptRevision || data.schemaVersion !== 1 ||
-                Object.keys(data).some(key => !['schemaVersion', 'snapshot', 'bundles', 'browserRevision', 'nodeRevision', 'managedModules', 'nodeSyncRequired', 'browserSyncRequired', 'nodeConfig', 'overrides'].includes(key)) || typeof data.nodeSyncRequired !== 'boolean' || (data.browserSyncRequired !== undefined && typeof data.browserSyncRequired !== 'boolean') ||
+                Object.keys(data).some(key => !['schemaVersion', 'snapshot', 'bundles', 'browserRevision', 'nodeRevision', 'managedModules', 'nodeSyncRequired', 'browserSyncRequired', 'overrides'].includes(key)) || typeof data.nodeSyncRequired !== 'boolean' || (data.browserSyncRequired !== undefined && typeof data.browserSyncRequired !== 'boolean') ||
                 data.nodeRevision !== activation.revision || !Array.isArray(data.bundles) || data.bundles.length > 64 ||
                 !Array.isArray(data.managedModules) || new Set(data.managedModules).size !== data.managedModules.length || data.managedModules.some(id => typeof id !== 'string' || !Object.hasOwn(activation.modules, id))) {
                 throw new BundleError('BUNDLE_INTEGRITY', 'Installed preset receipt does not match its selection');
             }
             const acceptedOverrides = overrides(data.overrides);
-            const nodeConfig = validateNodeModuleConfig(data.nodeConfig);
             let total = 0;
             const metadata = data.bundles.map(bundle => {
                 if (Object.keys(bundle).some(key => !['source', 'manifest', 'revision'].includes(key)))
@@ -116,18 +115,18 @@ export class PresetInstallationStore {
                 if (bytes.byteLength !== entry.byteLength || digest(bytes) !== entry.sha256)
                     throw new BundleError('BUNDLE_INTEGRITY', 'Installed Node object is missing or corrupt');
             }
-            return { receipt: { ...receipt, overrides: acceptedOverrides, nodeConfig }, bundles };
+            return { receipt: { ...receipt, overrides: acceptedOverrides }, bundles };
         });
         if (options.verifyResources === false) {
             const graph = await verifyPreset(captured.receipt.snapshot, this.mearlApiVersion);
-            await verifyBrowserPreset({ source: graph.snapshot.source, manifests: graph.snapshot.manifests,
-                bundleRevisions: Object.fromEntries(Object.entries(graph.snapshot.bundleRevisions).filter(([id]) => graph.preset.packages[id].runtimes?.includes('browser'))), revision: captured.receipt.browserRevision }, this.mearlApiVersion);
+            await verifyBrowserPreset({ source: graph.snapshot.source, manifests: graph.snapshot.manifests, packageTargets: graph.snapshot.packageTargets,
+                bundleRevisions: Object.fromEntries(Object.entries(graph.snapshot.bundleRevisions).filter(([id]) => graph.preset.packages[id].targets?.includes('browser'))), revision: captured.receipt.browserRevision }, this.mearlApiVersion);
             return { rawHash, activation, receipt: captured.receipt, preset: graph.preset };
         }
         const prepared = await verifyPreparedPreset({ snapshot: captured.receipt.snapshot, bundles: captured.bundles }, this.mearlApiVersion);
         if (prepared.browser.snapshot.revision !== captured.receipt.browserRevision)
             throw new BundleError('BUNDLE_INTEGRITY', 'Installed browser projection does not match');
-        const selected = await prepareNodeBundleSnapshot(prepared.bundles.filter(bundle => prepared.preset.packages[bundle.manifest.id].runtimes?.includes('node')), 'native-host', this.mearlApiVersion, resolvePresetModuleConfig(mergePresetDefaults(prepared.preset.defaults, captured.receipt.overrides), captured.receipt.nodeConfig));
+        const selected = await prepareNodeBundleSnapshot(prepared.bundles.filter(bundle => prepared.preset.packages[bundle.manifest.id].targets?.includes('node')), 'native-host', this.mearlApiVersion, resolveCapabilityConfig(mergePresetDefaults(prepared.preset.defaults, captured.receipt.overrides)));
         if (Object.keys(selected.snapshot.modules).length !== captured.receipt.managedModules.length || captured.receipt.managedModules.some(id => !Object.hasOwn(selected.snapshot.modules, id)) ||
             Object.entries(selected.snapshot.modules).some(([id, entry]) => JSON.stringify(entry) !== JSON.stringify(activation.modules[id])) ||
             Object.entries(selected.snapshot.bindings).some(([hook, entry]) => JSON.stringify(entry) !== JSON.stringify(activation.bindings[hook])) ||
@@ -139,12 +138,10 @@ export class PresetInstallationStore {
     async apply(input, options) {
         options.signal?.throwIfAborted();
         const acceptedOverrides = options.overrides === undefined ? undefined : overrides(options.overrides);
-        const nodeConfig = options.nodeConfig === undefined ? undefined : validateNodeModuleConfig(options.nodeConfig);
         const [current, prepared] = await Promise.all([this.current({ verifyResources: false }), verifyPreparedPreset(input, this.mearlApiVersion)]);
         if (revision(current) !== options.expectedRevision)
             throw new BundleError('BUNDLE_CONFLICT', 'The installed preset changed');
-        const configured = nodeConfig ?? current.receipt?.nodeConfig ?? Object.fromEntries(Object.entries(current.activation?.modules ?? {}).filter(([, entry]) => entry.config !== undefined).map(([id, entry]) => [id, entry.config]));
-        const selected = await prepareNodeBundleSnapshot(prepared.bundles.filter(bundle => prepared.preset.packages[bundle.manifest.id].runtimes?.includes('node')), 'native-host', this.mearlApiVersion, resolvePresetModuleConfig(mergePresetDefaults(prepared.preset.defaults, acceptedOverrides ?? current.receipt?.overrides ?? {}), configured));
+        const selected = await prepareNodeBundleSnapshot(prepared.bundles.filter(bundle => prepared.preset.packages[bundle.manifest.id].targets?.includes('node')), 'native-host', this.mearlApiVersion, resolveCapabilityConfig(mergePresetDefaults(prepared.preset.defaults, acceptedOverrides ?? current.receipt?.overrides ?? {})));
         const previousManaged = new Set(current.receipt?.managedModules ?? []);
         const unmanaged = Object.fromEntries(Object.entries(current.activation?.modules ?? {}).filter(([id]) => !previousManaged.has(id)));
         for (const entry of Object.values(unmanaged)) {
@@ -157,15 +154,14 @@ export class PresetInstallationStore {
         const bindings = Object.fromEntries(Object.entries(current.activation?.bindings ?? {}).filter(([, entry]) => Object.hasOwn(unmanaged, entry.module)));
         if (Object.keys(selected.snapshot.bindings).some(hook => Object.hasOwn(bindings, hook)))
             throw new BundleError('BUNDLE_CONFLICT', 'A preset hook conflicts with an independently installed Node module');
-        const snapshot = await prepareNodeCapabilitySnapshot({ schemaVersion: 1, modules: { ...unmanaged, ...selected.snapshot.modules }, bindings: { ...bindings, ...selected.snapshot.bindings } });
+        const snapshot = await prepareCapabilitySnapshot({ schemaVersion: 1, modules: { ...unmanaged, ...selected.snapshot.modules }, bindings: { ...bindings, ...selected.snapshot.bindings } });
         const data = {
             schemaVersion: 1, snapshot: prepared.snapshot,
             bundles: prepared.bundles.map(({ source, revision, manifest }) => ({ source, revision, manifest })),
             browserRevision: prepared.browser.snapshot.revision, nodeRevision: snapshot.revision,
             managedModules: Object.keys(selected.snapshot.modules), overrides: acceptedOverrides ?? current.receipt?.overrides ?? {},
-            nodeSyncRequired: Boolean(current.receipt?.nodeSyncRequired || current.receipt?.managedModules.length || Object.values(prepared.preset.packages).some(entry => entry.enabled !== false && entry.runtimes?.includes('node'))),
+            nodeSyncRequired: Boolean(current.receipt?.nodeSyncRequired || current.receipt?.managedModules.length || Object.values(prepared.preset.packages).some(entry => entry.enabled !== false && entry.targets?.includes('node'))),
             browserSyncRequired: Boolean(current.receipt?.browserSyncRequired || presetRequiresBrowser(prepared.preset)),
-            nodeConfig: configured,
         };
         const receipt = { ...data, revision: digest(JSON.stringify(data)) };
         const receiptBytes = JSON.stringify(receipt);
@@ -207,7 +203,7 @@ export class PresetInstallationStore {
         const record = JSON.parse(readBounded(join(this.directory, 'rollback.json'), POINTER_BYTES + 256).toString('utf8'));
         if (record.candidate !== expectedRevision)
             throw new BundleError('BUNDLE_CONFLICT', 'The preset rollback record has changed');
-        const previous = record.previous === null ? undefined : await verifyNodeCapabilityActivation(record.previous);
+        const previous = record.previous === null ? undefined : await verifyCapabilityActivation(record.previous);
         withRecordLock(this.pointer, () => {
             this.assertCurrent(current.rawHash);
             if (previous)
@@ -222,7 +218,7 @@ export class PresetInstallationStore {
         const current = await this.current({ verifyResources: false });
         const raw = optionalFile(join(this.directory, 'rollback.json'), POINTER_BYTES + 256);
         const record = raw && JSON.parse(raw.toString('utf8'));
-        const previous = record?.candidate === current.activation?.installationRevision && record.previous !== null ? await verifyNodeCapabilityActivation(record.previous) : undefined;
+        const previous = record?.candidate === current.activation?.installationRevision && record.previous !== null ? await verifyCapabilityActivation(record.previous) : undefined;
         withRecordLock(this.pointer, () => {
             this.assertCurrent(current.rawHash);
             for (const child of ['blobs', 'objects', 'installations'])

package/dist/setupPreset.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+import { PresetInstaller, type StagedPresetInstallation } from './preset.js';
+/** Preserve the accepted installation and resume its exact resources before Skill operations. */
+export declare function prepareSetupPreset(options: {
+    source?: string;
+    fallbackSource?: string;
+    env?: NodeJS.ProcessEnv;
+}, dependencies?: {
+    installer?: PresetInstaller;
+}): Promise<StagedPresetInstallation | undefined>;

package/dist/setupPreset.js ADDED Viewed

@@ -0,0 +1,14 @@
+import { PresetInstaller } from './preset.js';
+/** Preserve the accepted installation and resume its exact resources before Skill operations. */
+export async function prepareSetupPreset(options, dependencies = {}) {
+    const installer = dependencies.installer ?? new PresetInstaller({ directory: (options.env ?? process.env).MEARL_CAPABILITY_DIR });
+    if (options.source)
+        return installer.stage(options.source);
+    const current = await installer.store.current();
+    if (current.receipt)
+        return { revision: current.receipt.revision, activate: () => installer.resume(current.receipt.revision) };
+    if (current.activation)
+        return;
+    if (options.fallbackSource)
+        return installer.stage(options.fallbackSource);
+}

package/dist/setupVersion.js CHANGED Viewed

@@ -1,4 +1,4 @@
 import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);
 export const SETUP_VERSION = require('../package.json').version;
-export const SETUP_COMMAND = `npx --@mearl:registry=https://registry.npmjs.org @mearl/setup${SETUP_VERSION.includes('-beta.') ? '@' + SETUP_VERSION : ''}`;
+export const SETUP_COMMAND = `npx @mearl/setup${SETUP_VERSION.includes('-beta.') ? '@beta' : ''}`;

package/dist/skills.js CHANGED Viewed

@@ -4,11 +4,11 @@ import { homedir } from 'node:os';
 import { NodeCapabilityRegistry } from '@mearl/daemon-core/capabilities';
 import { inspectGlobalSkill, readTrackedSkillSources } from './skillSources.js';
 import { PresetInstallationStore } from './presetStore.js';
-import { findExecutable, isExecutable, prependCommandPath, prependNodePath, runCommand, } from '@mearl/daemon-core';
+import { findExecutable, isExecutable, npmExecEnvironment, prependCommandPath, prependNodePath, runCommand, } from '@mearl/daemon-core';
 export const SKILLS_CLI_PACKAGE = 'skills@1.5.0';
 export const MEARL_SKILL_SOURCE = SETUP_VERSION.includes('-beta.')
-    ? `https://github.com/F-loat/mearl/tree/v${SETUP_VERSION}`
-    : 'https://github.com/F-loat/mearl';
+    ? `https://github.com/mearlhq/mearl/tree/v${SETUP_VERSION}`
+    : 'https://github.com/mearlhq/mearl';
 const COMMAND_TIMEOUT_MS = 120_000;
 const ANSI_ESCAPE_PATTERN = new RegExp(String.raw `\u001B\[[0-?]*[ -/]*[@-~]`, 'g');
 export function stripAnsi(value) {
@@ -41,7 +41,7 @@ export function resolveSkillsInvocation(options = {}) {
     return {
         command: npx,
         argsPrefix: ['-y', SKILLS_CLI_PACKAGE],
-        env: prependNodePath(prependCommandPath(npx, env), processExecPath),
+        env: npmExecEnvironment(prependNodePath(prependCommandPath(npx, env), processExecPath)),
     };
 }
 /** Only the selected manager module is needed; browser and Provider factories stay in their hosts. */

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@mearl/setup",
-  "version": "3.0.0-beta.4",
+  "version": "3.0.0-beta.7",
   "description": "One-shot environment setup and configuration for Mearl",
   "type": "module",
   "main": "dist/index.js",
@@ -68,31 +68,32 @@
   ],
   "license": "Apache-2.0",
   "engines": {
-    "node": ">=22.12.0"
+    "node": ">=20.18.0"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "commander": "^15.0.0",
-    "extract-zip": "^2.0.1",
+    "commander": "^14.0.3",
     "ws": "^8.18.3",
     "semver": "^7.8.5",
-    "@mearl/client": "3.0.0-beta.4",
-    "@mearl/provider": "3.0.0-beta.4",
-    "@mearl/daemon-core": "3.0.0-beta.4",
-    "@mearl/preset": "3.0.0-beta.4",
-    "@mearl/browser-core": "3.0.0-beta.4"
+    "adm-zip": "^0.6.1",
+    "@mearl/client": "3.0.0-beta.7",
+    "@mearl/provider": "3.0.0-beta.7",
+    "@mearl/daemon-core": "3.0.0-beta.7",
+    "@mearl/preset": "3.0.0-beta.7",
+    "@mearl/browser-core": "3.0.0-beta.7"
   },
   "devDependencies": {
     "@types/node": "^24.9.1",
     "@types/ws": "^8.18.1",
     "typescript": "^5.8.3",
-    "@types/semver": "^7.7.1"
+    "@types/semver": "^7.7.1",
+    "@types/adm-zip": "^0.5.7"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/F-loat/mearl.git",
+    "url": "git+https://github.com/mearlhq/mearl.git",
     "directory": "packages/setup"
   },
   "scripts": {

package/dist/presetUpgrade.d.ts DELETED Viewed

@@ -1,13 +0,0 @@
-import { type InstallationConfig } from '@mearl/preset/installation';
-import { PresetInstaller, type StagedPresetInstallation } from './preset.js';
-import { type DetectedGlobalPackage } from './packageManager.js';
-export declare const MEARL_INSTALLATION_CONFIG_URL = "https://f-loat.github.io/mearl/installation.json";
-/** Reuse the installation receipt as the retry marker; organization defaults come from deployment data. */
-export declare function prepareSetupPreset(options: {
-    source?: string;
-    installed?: Array<Pick<DetectedGlobalPackage, 'packageName' | 'packageRoot'>>;
-    env?: NodeJS.ProcessEnv;
-}, dependencies?: {
-    installer?: PresetInstaller;
-    configuration?: () => Promise<InstallationConfig>;
-}): Promise<StagedPresetInstallation | undefined>;

package/dist/presetUpgrade.js DELETED Viewed

@@ -1,42 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { loadInstallationConfig } from '@mearl/preset/installation';
-import { PresetInstaller } from './preset.js';
-import { detectGlobalPackage } from './packageManager.js';
-import { detectMearlProfiles } from './profiles.js';
-export const MEARL_INSTALLATION_CONFIG_URL = 'https://f-loat.github.io/mearl/installation.json';
-function isLegacyPackage(installation) {
-    try {
-        const manifest = JSON.parse(readFileSync(join(installation.packageRoot, 'package.json'), 'utf8'));
-        return manifest.name === installation.packageName && typeof manifest.version === 'string' && /^[0-2]\.\d+\.\d+(?:[-+][\w.-]+)?$/.test(manifest.version);
-    }
-    catch {
-        return false;
-    }
-}
-/** Reuse the installation receipt as the retry marker; organization defaults come from deployment data. */
-export async function prepareSetupPreset(options, dependencies = {}) {
-    const env = options.env ?? process.env;
-    const installer = dependencies.installer ?? new PresetInstaller({ directory: env.MEARL_CAPABILITY_DIR });
-    if (options.source)
-        return installer.stage(options.source);
-    const current = await installer.store.current();
-    if (current.receipt)
-        return { revision: current.receipt.revision, activate: () => installer.resume(current.receipt.revision) };
-    if (current.activation)
-        return;
-    const client = options.installed === undefined ? detectGlobalPackage('@mearl/client', ['mearl'], { env }) : null;
-    const installed = options.installed ?? [...detectMearlProfiles({ env }).values(), ...(client ? [client] : [])];
-    if (!installed.some(isLegacyPackage))
-        return;
-    const configuration = dependencies.configuration ?? (() => {
-        const url = new URL(env.MEARL_INSTALLATION_CONFIG_URL || MEARL_INSTALLATION_CONFIG_URL);
-        if (url.protocol !== 'https:' && !(url.protocol === 'http:' && ['127.0.0.1', 'localhost', '[::1]'].includes(url.hostname)))
-            throw new Error('Installation configuration requires HTTPS or loopback HTTP');
-        return loadInstallationConfig(url, url.origin, AbortSignal.timeout(5_000));
-    });
-    const config = await configuration();
-    if (!config.legacyPreset)
-        throw new Error('Legacy upgrade preset is unavailable. Retry when the installation catalog is available, or select a preset with --preset.');
-    return installer.stage(config.presets[config.legacyPreset].source, { expectedRevision: null, expectedId: config.legacyPreset });
-}