@aalis/plugin-package-manager 0.8.1 → 0.10.0

package/dist/index.js

@@ -1,17 +1,20 @@
 import { createRequire } from 'node:module';
+import { failureText, unmetDependencies } from '@aalis/api-doctor';
 import { hostConfig } from '@aalis/api-host-config';
+import { hostPaths } from '@aalis/api-host-paths';
 import { packageManager, } from '@aalis/api-package-manager';
 import { pluginDefinitionOf, pluginSource } from '@aalis/api-plugin-source';
-import { createProcessGateway, processService } from '@aalis/api-process';
-import { appService, config, definePlugin, logger, optional, pluginsService, provide, services, } from '@aalis/core';
-import { defineConfig, parseConfig } from '@aalis/schema-config';
+import { processService } from '@aalis/api-process';
+import { appService, definePlugin, logger, optional, pluginsService, provide, services, } from '@aalis/core';
+import { TextError, textClauses, textOf, toSource } from '@aalis/schema-i18n';
 import { classifyDepSpec, isRegistryDep, isUpgrade } from '@aalis/util-dep-spec';
+import { t } from './texts.js';
 // ===== 实现 =====
 /** 短命令（cp、npm view 等）的超时。 */
 const QUICK_TIMEOUT_MS = 120_000;
 /**
- * 安装类命令的超时。`npm install` 要装全依赖树 + 原生编译（better-sqlite3、puppeteer
- * 都在脚手架默认依赖里），快机快网下已达 95 秒量级，而超时行为是 SIGKILL——留足余量，
+ * 安装类命令的超时。`npm install` 要装全依赖树并跑依赖的安装脚本（比如 plugin-tool-browser
+ * 依赖的 puppeteer 安装时要下载 Chrome），快机快网下已达 95 秒量级，而超时行为是 SIGKILL——留足余量，
  * 否则会在半装状态下被杀。
  */
 const INSTALL_TIMEOUT_MS = 600_000;
@@ -75,8 +78,8 @@ export function declaresPlugin(pkgJson) {
 }
 /**
  * 包类型是否归市场装卸：插件（判据同 {@link declaresPlugin}）与前端界面（`aalis-interface`）
- * 归市场管，返回 `undefined`；其余返回拒绝时展示的类别名。装与卸共用这一份判据——同一件事
- * 维护两份同义判据，正是本仓已出事四次的形态（依赖来源判据、定级数学、包名正则、关键词分类）。
+ * 归市场管，返回 `undefined`；其余按类型关键词返回种类码（没有类型关键词的是 other），拒绝时显示 KIND_NAMES 里的名字。
+ * 装与卸共用这一份判据——同一件事维护两份同义判据，正是本仓已出事四次的形态（依赖来源判据、定级数学、包名正则、关键词分类）。
  * 纯函数，便于单测。
  */
 export function nonMarketKind(keywords) {
@@ -84,37 +87,48 @@ export function nonMarketKind(keywords) {
     if (declaresPlugin({ keywords: kw }) || kw.includes('aalis-interface'))
         return undefined;
     if (kw.includes('aalis-core'))
-        return '内核';
+        return 'core';
     if (kw.includes('aalis-runtime'))
-        return '宿主';
+        return 'runtime';
     if (kw.includes('aalis-api'))
-        return '服务契约';
+        return 'api';
     if (kw.includes('aalis-schema'))
-        return '数据规范';
+        return 'schema';
     if (kw.includes('aalis-util'))
-        return '工具库';
-    return '非插件包';
+        return 'util';
+    return 'other';
 }
+/** 不归市场装卸的包种类给人看的名字 */
+const KIND_NAMES = {
+    core: t('kindCore'),
+    runtime: t('kindRuntime'),
+    api: t('kindApi'),
+    schema: t('kindSchema'),
+    util: t('kindUtil'),
+    other: t('kindOther'),
+};
 /**
- * 找出「卸载 target 会断其服务依赖」的插件：target 提供的某服务 S 没有别的插件正在提供（只认 active 与
- * activating；disabled / error / pending 的同类提供者不在提供），且有别的插件 requiredServices 含 S → 这些插件
- * 会被打断。已禁用（disabled / disposed）的依赖者不算。纯函数，便于单测。
+ * 找出「卸载 target 会断其服务依赖」的插件：target 的某个实例正在提供或马上就提供的某服务 S 没有别的插件正在提供，且有别的
+ * 插件 required 依赖 S（uses 里未包 optional）→ 这些插件会被打断。卸载连同 target 的全部实例一起卸下，所以按同名的每个实例判：算在提供的是
+ * active、activating，以及 pending 而只是在等的（按 api-doctor 的共享判据不缺什么，它要的在启动，起来就提供）；disabled、
+ * error 与 pending 而缺服务的不在提供。别的提供者只算 active 与 activating（替代得是确定的）。已禁用（disabled / disposed）
+ * 的依赖者不算。available 是当前有提供者的服务名（services.names()）。纯函数，便于单测。
  */
-export function findServiceDependents(targetName, status) {
-    const target = status.find(p => p.name === targetName);
-    const provided = target?.provides ?? [];
-    if (provided.length === 0)
-        return [];
+export function findServiceDependents(targetName, status, available) {
+    const providing = (p) => p.state === 'active' || p.state === 'activating';
+    const unmet = unmetDependencies(status, available);
+    const live = status.filter(p => p.name === targetName &&
+        (providing(p) || (p.state === 'pending' && unmet.get(p.instanceId)?.lacking.length === 0)));
     const dependents = new Set();
-    for (const svc of provided) {
-        const otherProvider = status.some(p => p.name !== targetName && (p.state === 'active' || p.state === 'activating') && (p.provides ?? []).includes(svc));
+    for (const svc of new Set(live.flatMap(p => p.provides ?? []))) {
+        const otherProvider = status.some(p => p.name !== targetName && providing(p) && (p.provides ?? []).includes(svc));
         if (otherProvider)
             continue; // 还有别的提供者在提供，删了不致命
         for (const p of status) {
             if (p.name !== targetName &&
                 p.state !== 'disabled' &&
                 p.state !== 'disposed' &&
-                (p.requiredServices ?? []).includes(svc)) {
+                p.uses.some(use => use.kind === 'required' && use.service === svc)) {
                 dependents.add(p.name);
             }
         }
@@ -155,25 +169,16 @@ const PKG_SPEC_RE = /^(@[a-z0-9][a-z0-9\-_.]*\/)?[a-z0-9][a-z0-9\-_.]*(@[a-z0-9]
  */
 export function validatePackageSpec(spec) {
     if (typeof spec !== 'string' || spec.length === 0)
-        return '包名必须是非空字符串';
+        return t('emptyName');
     if (!PKG_SPEC_RE.test(spec))
-        return `非法包名: ${JSON.stringify(spec)}`;
+        return t('badName', { name: JSON.stringify(spec) });
     return undefined;
 }
 // ===== 插件入口 =====
-const configSchema = defineConfig({
-    projectRoot: {
-        type: 'string',
-        label: '项目目录',
-        description: '安装插件的项目目录，留空使用当前工作目录；须与宿主的插件加载目录一致。',
-        default: '',
-        onInvalid: 'error',
-    },
-});
 const uses = {
     proc: processService,
+    paths: hostPaths,
     logger,
-    config,
     provide,
     services,
     app: optional(appService),
@@ -182,32 +187,19 @@ const uses = {
     source: optional(pluginSource),
 };
 function createService(caps) {
-    const cfg = parseConfig(configSchema, caps.config, caps.logger);
-    const log = caps.logger;
-    const proc = createProcessGateway(caps.proc);
+    const log = caps.logger.use;
+    const proc = caps.proc.use;
     function getApp() {
-        const app = caps.app.current;
-        if (!app)
-            throw new Error('app 服务不可用，无法执行包管理操作');
-        return app;
-    }
-    /** 把配置里的相对/绝对路径归一成绝对路径；未配置则用当前工作目录。 */
-    function projectRoot() {
-        const override = cfg.projectRoot;
-        if (override.length > 0) {
-            return override.startsWith('/') ? override : `${process.cwd()}/${override.replace(/^\.?\/+/, '')}`;
-        }
-        return process.cwd();
+        if (!caps.app.present)
+            throw new TextError(t('noApp'));
+        return caps.app.use;
     }
     return createPackageManager({
         proc,
-        log,
-        // 项目根：默认 cwd，与 createNodeModulesPluginLoader(projectDir = process.cwd()) 的
-        // 默认值同源——两者必须指同一处，否则「我们写的 package.json」与「加载器读的
-        // package.json」是两份，装了永远不加载。
-        // 宿主若给 startAalis 传了非 cwd 的 projectDir（公开选项），必须用本配置项对齐。
-        projectRoot,
-        // 经 process 网关的 readExternalFile 读，而非 node:fs：目标（项目根 package.json、
+        log: log,
+        // 装到宿主的安装集：与插件加载器读的是同一份 package.json，否则装了永远不加载
+        projectRoot: () => caps.paths.use.app,
+        // 经 process 服务的 readExternalFile 读，而非 node:fs：目标（项目根 package.json、
         // lockfile、node_modules/<pkg>/package.json）在 storage 沙盒之外，而 readExternalFile
         // 正是文档给这一场景指定的「OS 直通读外部路径」通道——本插件也不在 biome 的 node:* 例外清单里。
         readText: async (absPath) => {
@@ -219,17 +211,21 @@ function createService(caps) {
             }
         },
         // 宿主不提供插件来源（打包宿主）时视同本次没有新插件；随后仍按注册表判定，声明为插件的包会报「未被加载」
-        rescanPlugins: async () => (await caps.source.current?.rescan()) ?? [],
+        rescanPlugins: async () => (await (caps.source.present ? caps.source.use.rescan() : undefined)) ?? [],
         // 判据取运行时注册表而非 rescan 返回值（理由见 PackageManagerDeps.isPluginRegistered）。
         // plugins 服务缺席时保守返回 false——宁可让「声明为插件却没加载」的诊断多报一次，
         // 也不要在真没装上时谎报成功。
-        isPluginRegistered: name => caps.plugins.current?.getStatus().some(p => p.name === name) ?? false,
-        pluginStatus: () => caps.plugins.current?.getStatus() ?? [],
+        isPluginRegistered: name => caps.plugins.present ? caps.plugins.use.getStatus().some(p => p.name === name) : false,
+        pluginStatus: () => (caps.plugins.present ? caps.plugins.use.getStatus() : []),
+        availableServices: () => caps.services.use.names(),
         idle: async () => {
-            await caps.plugins.current?.idle();
+            if (caps.plugins.present)
+                await caps.plugins.use.idle();
         },
-        resolveDefinitionName: pkgName => resolveInstalledDefinitionName(projectRoot(), pkgName),
-        listPluginInstanceIds: definitionName => (caps.plugins.current?.getStatus() ?? []).filter(p => p.name === definitionName).map(p => p.instanceId),
+        resolveDefinitionName: pkgName => resolveInstalledDefinitionName(caps.paths.use.app, pkgName),
+        listPluginInstanceIds: definitionName => (caps.plugins.present ? caps.plugins.use.getStatus() : [])
+            .filter(p => p.name === definitionName)
+            .map(p => p.instanceId),
         // 重启并交付回滚凭据。core 只透传 rollback（不解释形状），由 runtime 的重启策略
         // 在「新实例 ready 前夭折」时消费——触发者与执行者同为父进程，全程内存不落盘。
         //
@@ -250,23 +246,29 @@ function createService(caps) {
         // 而这三个都没有，故也不需要为此加解析。
         recoveryChannelProviders: () => [
             ...new Set(['webui-client', 'webui-server', packageManager.name].flatMap(service => {
-                const id = caps.services.inspect(service)[0]?.contextId;
+                const id = caps.services.use.inspect(service)[0]?.contextId;
                 return id ? [id] : [];
             })),
         ],
         unloadPlugin: async (name) => {
-            await caps.plugins.current?.unload(name);
+            if (caps.plugins.present)
+                await caps.plugins.use.unload(name);
         },
-        // 卸载后清残留配置：删 plugins.<name> 配置块 + 从 disabledPlugins 移除
-        // （否则重装会被"上次禁用"标记带成已禁用状态），并持久化。宿主没提供配置文档时无可清理。
-        cleanupConfig: name => {
-            const doc = caps.hostConfig.current;
-            if (!doc)
+        // 文档没有改动时不保存：没东西要写，也就不该因配置文件的状况报失败
+        cleanupConfig: async (instanceIds, removeConfig) => {
+            if (!caps.hostConfig.present)
                 return;
-            doc.removePluginConfig(name);
-            doc.setPluginEnabled(name, true);
-            // cleanupConfig 契约返 void；落盘失败只 warn，内存态已清、下次保存会带上
-            doc.save().catch(err => log.warn(`${name}: 卸载后配置清理落盘失败:`, err));
+            const doc = caps.hostConfig.use;
+            const plugins = doc.getAll().plugins;
+            const touched = instanceIds.filter(id => doc.isPluginDisabled(id) || (removeConfig && Object.hasOwn(plugins, id)));
+            if (touched.length === 0)
+                return;
+            for (const id of touched) {
+                doc.setPluginEnabled(id, true);
+                if (removeConfig)
+                    doc.removePluginConfig(id);
+            }
+            await doc.save();
         },
     });
 }
@@ -344,20 +346,20 @@ const SPEC_ARGV_BUDGET = 128 * 1024;
  */
 export function buildUpdateSpecs(targets) {
     if (!Array.isArray(targets) || targets.length === 0)
-        return { error: '未指定更新目标' };
+        return { error: t('noTargets') };
     const specs = [];
     const seen = new Set();
     let bytes = 0;
-    for (const t of targets) {
-        const name = typeof t?.name === 'string' ? t.name : '';
-        const version = typeof t?.version === 'string' ? t.version : '';
+    for (const target of targets) {
+        const name = typeof target?.name === 'string' ? target.name : '';
+        const version = typeof target?.version === 'string' ? target.version : '';
         if (!PKG_NAME_ONLY_RE.test(name))
-            return { error: `非法包名: ${JSON.stringify(name)}` };
+            return { error: t('badName', { name: JSON.stringify(name) }) };
         if (!VERSION_RE.test(version))
-            return { error: `非法版本号: ${name}@${JSON.stringify(version)}` };
+            return { error: t('badVersion', { name, version: JSON.stringify(version) }) };
         // 同名多版本会让 npm 取最后一个，静默丢弃前面的选择——宁可让用户重选。
         if (seen.has(name))
-            return { error: `同一包被指定了多次: ${name}` };
+            return { error: t('duplicateTarget', { name }) };
         seen.add(name);
         const spec = `${name}@${version}`;
         // 按**字节**计而非按个数：这些 spec 逐条成为 argv，而 execve 的约束是参数块的总字节数，
@@ -365,7 +367,7 @@ export function buildUpdateSpecs(targets) {
         // 超限即整批停下，与本函数其余校验同一策略：不猜、不截断。
         bytes += Buffer.byteLength(spec) + 1; // +1 = argv 之间的 NUL 分隔
         if (bytes > SPEC_ARGV_BUDGET) {
-            return { error: `更新目标过多：参数总长已超 ${SPEC_ARGV_BUDGET} 字节，请分批提交` };
+            return { error: t('tooManyTargets', { budget: SPEC_ARGV_BUDGET }) };
         }
         specs.push(spec);
     }
@@ -380,6 +382,79 @@ export function extractPeerConflicts(output) {
     const picked = lines.filter(l => /ERESOLVE|peer |Conflicting peer|Found:|Could not resolve|from the root project/i.test(l));
     return picked.map(l => l.replace(/^npm (ERR!|error|warn)\s*/i, '').trim()).filter(l => l.length > 0);
 }
+/**
+ * npm 失败的几类与给用户看的一句（原因与修法）。浏览器下载与原生编译先于网络认：它们的输出里也可能带网络错误码，但修法
+ * 不同
+ */
+const NPM_FAILURES = [
+    { kind: 'disk', match: /\bENOSPC\b/, describe: () => t('npmDisk') },
+    { kind: 'permission', match: /\bEACCES\b/, describe: () => t('npmPermission') },
+    {
+        kind: 'platform',
+        match: /\bEBADPLATFORM\b/,
+        describe: output => {
+            const pkg = /Unsupported platform for (\S+?)@\d/.exec(output)?.[1];
+            return pkg === undefined ? t('npmPlatformUnknown') : t('npmPlatform', { pkg });
+        },
+    },
+    {
+        kind: 'peer',
+        match: /\bERESOLVE\b/,
+        describe: output => t('npmPeer', { conflicts: textClauses(extractPeerConflicts(output)) }),
+    },
+    {
+        kind: 'browser',
+        match: /Failed to set up (?:chrome|chrome-headless-shell|firefox)\b|node_modules[\\/]puppeteer\s*$/m,
+        describe: () => t('npmBrowser'),
+    },
+    {
+        kind: 'native',
+        match: /gyp ERR!|node-gyp|prebuild-install/,
+        describe: output => {
+            const pkg = /^npm (?:error|ERR!) path \S*node_modules[\\/]((?:@[^\\/\s]+[\\/])?[^\\/\s]+)\s*$/m.exec(output)?.[1];
+            return pkg === undefined ? t('npmNativeUnknown') : t('npmNative', { pkg });
+        },
+    },
+    {
+        kind: 'missing',
+        match: /\b(E404|ETARGET)\b/,
+        // 镜像源同步有延迟，刚发布的版本可能还没有
+        describe: (_output, [, code]) => t('npmMissing', { code }),
+    },
+    {
+        kind: 'network',
+        match: /\b(ENOTFOUND|ETIMEDOUT|ECONNRESET|ECONNREFUSED|EAI_AGAIN)\b/,
+        describe: (_output, [, code]) => t('npmNetwork', { code }),
+    },
+];
+/** 按先后认 npm 的失败输出：第一个对上的类别与匹配结果 */
+function recognizeNpmFailure(output) {
+    for (const failure of NPM_FAILURES) {
+        const found = failure.match.exec(output);
+        if (found)
+            return { failure, found };
+    }
+    return undefined;
+}
+/** npm 的失败输出认出是哪一类，认不出时为 undefined。纯函数，便于单测 */
+export function npmFailureKind(output) {
+    return recognizeNpmFailure(output)?.failure.kind;
+}
+/**
+ * 把 npm 的失败输出归成一句给用户看的话：认得出的写原因与修法，认不出的写 npm 的最后一条报错，并指向日志与排障页。
+ * 整段输出由调用方记进日志，回执与提示里只放这一句。纯函数，便于单测。
+ */
+export function describeNpmFailure(output) {
+    const known = recognizeNpmFailure(output);
+    if (known)
+        return known.failure.describe(output, known.found);
+    const errors = output
+        .split('\n')
+        .map(line => /^npm (?:error|ERR!)\s*(.*)$/.exec(line.trim())?.[1]?.trim())
+        .filter((line) => !!line && !line.startsWith('A complete log of this run'));
+    const last = errors.at(-1) ?? output.trim().split('\n').at(-1)?.trim();
+    return t('npmOther', { error: String(last) });
+}
 /**
  * 从 **成功**（exit 0）的 dry-run 输出里找出因本次目标而无法满足的 peer 依赖。
  *
@@ -395,7 +470,7 @@ export function extractPeerConflicts(output) {
 export function findUnmetPeers(output, targetNames) {
     const names = new Set(targetNames);
     // npm 会把同一条 peer 冲突在不同上下文里重复打印，去重后再给用户。
-    const out = new Set();
+    const out = new Map();
     for (const raw of output.split('\n')) {
         const line = raw.replace(/^npm (ERR!|error|warn)\s*/i, '').trim();
         const m = /^peer\s+(\S+?)@"([^"]+)"\s+from\s+(.+)$/.exec(line);
@@ -403,13 +478,13 @@ export function findUnmetPeers(output, targetNames) {
             continue;
         if (!names.has(m[1]))
             continue;
-        out.add(`${m[3]} 需要 ${m[1]}@${m[2]}`);
+        out.set(`${m[3]}\0${m[1]}@${m[2]}`, t('needsPeer', { dependent: m[3], peer: `${m[1]}@${m[2]}` }));
     }
-    return [...out];
+    return [...out.values()];
 }
 /**
- * 包管理核心：install/uninstall 的纯依赖实现（不碰能力/网关，可单测）。
- * 所有文件操作走 process 网关（子进程：npm/cp/test），目标是项目根 package.json 与
+ * 包管理核心：install/uninstall 的纯依赖实现（不碰服务选择，可单测）。
+ * 所有文件操作走 process 服务（子进程：npm/cp/test），目标是项目根 package.json 与
  * node_modules——不经 storage 沙盒。
  * 能力组装层见 createService。
  */
@@ -443,7 +518,7 @@ export function createPackageManager(deps) {
      */
     async function exclusive(what, run) {
         if (inflight) {
-            return { ok: false, message: `有包管理操作正在进行中（${inflight}），请稍候重试` };
+            return { ok: false, message: t('busy', { operation: inflight }) };
         }
         inflight = what;
         try {
@@ -454,6 +529,17 @@ export function createPackageManager(deps) {
                 inflight = null;
         }
     }
+    /** 跑一条 npm 命令：失败时整段输出记进日志，抛出的错误只带 {@link describeNpmFailure} 认出的原因与修法 */
+    async function npm(args, cwd, timeout, extraEnv) {
+        try {
+            return (await execProcBoth(proc, 'npm', args, cwd, timeout, extraEnv)).stdout;
+        }
+        catch (err) {
+            const output = err instanceof Error ? err.message : String(err);
+            log.error(`npm ${args.join(' ')} 失败: ${output}`);
+            throw new TextError(describeNpmFailure(output));
+        }
+    }
     /** 安装源查询的缓存：只留成功的结果，失败时清掉，下次调用重查 */
     let registryUrl;
     function registry() {
@@ -475,7 +561,7 @@ export function createPackageManager(deps) {
     /** 路径存在性：`test -d|-f <abs>`（不存在 → exit 1 → 抛 → false）。绝对路径，cwd 无关。 */
     async function pathExists(absPath, kind) {
         try {
-            await proc.execFile('test', [`-${kind}`, absPath], { cwd: process.cwd(), timeout: 10_000 });
+            await proc.execFile('test', [`-${kind}`, absPath], { cwd: deps.projectRoot(), timeout: 10_000 });
             return true;
         }
         catch {
@@ -515,17 +601,14 @@ export function createPackageManager(deps) {
      * HTTP 路由——本服务对外公开，任何插件都能绕过路由直接调。返回拒绝理由，`undefined` = 放行。
      */
     async function installKindRefusal(npmPkg, root) {
-        const out = (await execProc(proc, 'npm', ['view', npmPkg, 'keywords', '--json'], root)).trim();
+        const out = (await npm(['view', npmPkg, 'keywords', '--json'], root)).trim();
         // 包没有 keywords 字段时 npm 什么都不输出；spec 是版本范围时按版本逐个给出、返回二维数组
         const parsed = out ? JSON.parse(out) : [];
         const perVersion = Array.isArray(parsed) && parsed.length > 0 && parsed.every(Array.isArray) ? parsed : [parsed];
         const kind = perVersion.map(kw => nonMarketKind(kw)).find(k => k !== undefined);
         if (!kind)
             return undefined;
-        return (`${npmPkg} 是${kind}，不是可装卸的插件，市场不负责它的安装。` +
-            (kind === '非插件包'
-                ? '市场只安装带 aalis-plugin / aalis-interface 关键词的包。'
-                : '它随脚手架或依赖它的插件自动就位；要升级已装的版本，请在市场勾选它后用「更新所选」提交。'));
+        return t(kind === 'other' ? 'installUnmarked' : 'installBundled', { name: npmPkg, kind: KIND_NAMES[kind] });
     }
     /**
      * 装完的统一判定：rescan 出新插件即成功；没出新插件时按目标是否**声明自己是插件**分流。
@@ -541,21 +624,21 @@ export function createPackageManager(deps) {
         if (deps.isPluginRegistered(defName)) {
             await deps.idle?.();
             const main = deps.pluginStatus?.().find(p => p.instanceId === defName);
+            const settled = (message) => ({ ok: true, message, plugin: defName });
             switch (main?.state) {
                 case 'error':
-                    return { ok: true, message: `已安装 ${target}，但激活失败，已转为 error 态（${main.error ?? '详见日志'}）` };
+                    return settled(t('installedErrored', { target, error: failureText(main) ?? t('seeLogs') }));
                 case 'activating':
-                    return { ok: true, message: `已安装 ${target}，仍在激活（超过慢激活阈值，已转入后台），结果以插件列表为准` };
+                    return settled(t('installedActivating', { target }));
                 case 'pending':
-                    return { ok: true, message: `已安装 ${target}，尚未激活，正在等待 required 依赖满足` };
+                    return settled(t('installedPending', { target }));
             }
-            return { ok: true, message: `已安装并加载: ${target}` };
+            return settled(t('installedLoaded', { target }));
         }
         const meta = await readJson(installedPkgJsonPath);
-        if (declaresPlugin(meta)) {
-            return { ok: false, message: `已装到 ${where}，但它声明为插件却未被加载——请检查其 keywords 与入口导出` };
-        }
-        return { ok: true, message: `已安装 ${target}（非插件包，不进入插件列表）` };
+        if (declaresPlugin(meta))
+            return { ok: false, message: t('installedNotLoaded', { where }) };
+        return { ok: true, message: t('installedNonPlugin', { target }) };
     }
     /**
      * 安装：写根 `dependencies` —— 加载器**唯一**的发现来源。
@@ -563,7 +646,7 @@ export function createPackageManager(deps) {
      * 不按「项目形态」分叉：检测到 `pnpm-workspace.yaml` 就把 npm 包解包成
      * `packages/<dir>` 源码是错的——那个文件与真正生效的加载器**没有因果关系**，加载器是入口
      * 文件传给 `startAalis` 的（默认读根依赖，本仓显式传 fs 加载器扫 packages/）。于是一个
-     * 用 pnpm 工作区但走默认 `startAalis()` 的用户，包会被装进加载器永远不看的地方，静默失败。
+     * 用 pnpm 工作区、却不给 `startAalis` 传插件加载器（走默认的 node_modules 加载器）的用户，包会被装进加载器永远不看的地方，静默失败。
      *
      * 只有一条路径。真正的 monorepo 由下面的 `hasWorkspaceProtocol` 守卫拦住并说清
      * 该用什么工具——那才是开发者场景，不该用市场往自己仓里塞源码。
@@ -572,10 +655,7 @@ export function createPackageManager(deps) {
         const root = deps.projectRoot();
         const rootPkg = await readJson(`${root}/package.json`);
         if (hasWorkspaceProtocol(rootPkg)) {
-            return {
-                ok: false,
-                message: '根依赖含 workspace: 协议，拒绝在此运行 npm install（会写出 package-lock.json 并搅坏 pnpm 工作区）',
-            };
+            return { ok: false, message: t('workspaceInstall') };
         }
         const refused = await installKindRefusal(npmPkg, root);
         if (refused)
@@ -583,22 +663,13 @@ export function createPackageManager(deps) {
         log.info(`正在安装: ${npmPkg} → 根依赖 + node_modules`);
         // **刻意不加 `--ignore-scripts`**：依赖树的 preinstall/install/postinstall 会照常执行。
         // 三条理由：脚手架自身就是裸 `npm install`（其生成的 README 也教用户裸装），加了会让
-        // 「同一个包、同一个用户、两条途径」行为分叉；会打穿 plugin-memory-sqlite
-        // （better-sqlite3，脚手架默认勾选）与 plugin-tool-browser（puppeteer）；而真正的增量
+        // 「同一个包、同一个用户、两条途径」行为分叉；会打穿 plugin-tool-browser（puppeteer）；而真正的增量
         // 风险只有传递依赖的 install 脚本这一片——入口是 owner 级、包名由用户自己点选、包本体
         // 反正会被动态 import 执行（插件与内核同进程同权限，见 docs/concepts/security-model.md §1）。
         //
         // peer 护栏与更新预检相同（STRICT_PEERS_ENV）。代价：本就靠 legacy-peer-deps 容忍既有
-        // peer 冲突的项目，市场安装会整体失败，故失败文案要点明原因。
-        try {
-            await execProcBoth(proc, 'npm', ['install', npmPkg, '--no-audit', '--no-fund'], root, INSTALL_TIMEOUT_MS, STRICT_PEERS_ENV);
-        }
-        catch (err) {
-            const raw = err instanceof Error ? err.message : String(err);
-            if (!raw.includes('ERESOLVE'))
-                throw err;
-            throw new Error(`peer 依赖冲突，未安装（市场安装不沿用 .npmrc 里的 legacy-peer-deps）：${extractPeerConflicts(raw).join('；')}`);
-        }
+        // peer 冲突的项目，市场安装会整体失败，故失败文案要点明原因（见 describeNpmFailure）。
+        await npm(['install', npmPkg, '--no-audit', '--no-fund'], root, INSTALL_TIMEOUT_MS, STRICT_PEERS_ENV);
         const bare = stripVersion(npmPkg);
         return settleInstall(npmPkg, `${root}/node_modules/${bare}/package.json`, 'node_modules');
     }
@@ -629,23 +700,29 @@ export function createPackageManager(deps) {
     async function preflightInSandbox(specs, root) {
         const tmp = await proc.makeTempDir('preflight');
         try {
-            // 直接 cp 现有文件，不重新写内容——与本插件其余文件操作同一路子（走 proc 网关的
+            // 直接 cp 现有文件，不重新写内容——与本插件其余文件操作同一路子（走 process 服务的
             // POSIX 命令），也省掉一个只为此处存在的写原语。
             await execProc(proc, 'cp', [`${root}/package.json`, `${tmp.path}/package.json`], tmp.path);
             const lock = `${root}/package-lock.json`;
             if (await pathExists(lock, 'f')) {
                 await execProc(proc, 'cp', [lock, `${tmp.path}/package-lock.json`], tmp.path);
             }
-            const { stdout, stderr } = await execProcBoth(proc, 'npm', ['install', ...specs, '--dry-run', '--no-audit', '--no-fund'], tmp.path, INSTALL_TIMEOUT_MS, STRICT_PEERS_ENV);
-            const unmet = findUnmetPeers(`${stderr}\n${stdout}`, specs.map(stripVersion));
+            let output;
+            try {
+                output = await execProcBoth(proc, 'npm', ['install', ...specs, '--dry-run', '--no-audit', '--no-fund'], tmp.path, INSTALL_TIMEOUT_MS, STRICT_PEERS_ENV);
+            }
+            catch (err) {
+                // 非零退出：npm 判定 peer 无解（ERESOLVE 等）时报冲突要点；别的失败（连不上源等）不是冲突，抛出原因与修法
+                const raw = err instanceof Error ? err.message : String(err);
+                const conflicts = extractPeerConflicts(raw);
+                if (conflicts.length > 0)
+                    return conflicts;
+                log.error(`更新预检失败: ${raw}`);
+                throw new TextError(describeNpmFailure(raw));
+            }
+            const unmet = findUnmetPeers(`${output.stderr}\n${output.stdout}`, specs.map(stripVersion));
             return unmet.length > 0 ? unmet : undefined;
         }
-        catch (err) {
-            // 非零退出 = npm 自己判定无解（ERESOLVE 等）。原样上报，不猜。
-            const raw = err instanceof Error ? err.message : String(err);
-            const conflicts = extractPeerConflicts(raw);
-            return conflicts.length > 0 ? conflicts : [raw.slice(0, 2000)];
-        }
         finally {
             await tmp.cleanup().catch(() => { });
         }
@@ -655,11 +732,12 @@ export function createPackageManager(deps) {
      * 重启次数恒为 1，与改了多少个包无关（语义见 {@link PackageManagerService.update}）。
      */
     async function updateAll(targets) {
-        const { specs, error } = buildUpdateSpecs(targets);
-        if (!specs)
-            return { ok: false, message: error ?? '参数非法' };
+        const built = buildUpdateSpecs(targets);
+        if (built.error)
+            return { ok: false, message: built.error };
+        const { specs } = built;
         if (!deps.restartApp)
-            return { ok: false, message: '当前宿主未提供重启能力，无法完成更新' };
+            return { ok: false, message: t('noRestart') };
         const root = deps.projectRoot();
         // 没有「项目形态」这一层判断了：能不能更新是**每个包自己的来源**说了算（下面的
         // isRegistryDep 闸），不是整个项目的属性。旧写法拿 `pnpm-workspace.yaml` 是否存在
@@ -667,34 +745,29 @@ export function createPackageManager(deps) {
         const rootPkgPath = `${root}/package.json`;
         const rootPkgText = await deps.readText(rootPkgPath);
         if (rootPkgText === undefined)
-            return { ok: false, message: `读不到根 package.json: ${rootPkgPath}` };
+            return { ok: false, message: t('noRootPackage', { path: rootPkgPath }) };
         const rootPkg = await readJson(rootPkgPath);
-        if (hasWorkspaceProtocol(rootPkg)) {
-            return { ok: false, message: '根依赖含 workspace: 协议，拒绝在此运行 npm install' };
-        }
+        if (hasWorkspaceProtocol(rootPkg))
+            return { ok: false, message: t('workspaceUpdate') };
         // 只允许更新「根依赖里以 semver 范围声明」的包。闸放在服务层而非 HTTP 路由——
         // 本服务对外公开，任何插件都能绕过路由直接调用（理由见 isRegistryDep）。
         const rootDependencies = (rootPkg?.dependencies ?? {});
-        const notUpdatable = targets.filter(t => !isRegistryDep(rootDependencies[t.name]));
+        const notUpdatable = targets.filter(target => !isRegistryDep(rootDependencies[target.name]));
         if (notUpdatable.length > 0) {
-            return {
-                ok: false,
-                message: '以下包不在根依赖中（由其它插件带入）或不是 registry 来源，单独更新只会装出第二份副本；' +
-                    `请改为更新带入它们的插件：${notUpdatable.map(t => t.name).join('、')}`,
-            };
+            return { ok: false, message: t('notUpdatable', { names: notUpdatable.map(target => target.name) }) };
         }
         // ── 读取每个目标的当前实装版本 ──
         // 两处都要用：(a) 降级守卫；(b) 回滚凭据钉精确旧版。两者都不能靠根 package.json 的
         // 声明——那是**范围**，回滚时按范围重解析只会又解到刚崩掉的新版。
         const installedVersions = new Map();
-        for (const t of targets) {
-            const text = await deps.readText(`${root}/node_modules/${t.name}/package.json`);
+        for (const target of targets) {
+            const text = await deps.readText(`${root}/node_modules/${target.name}/package.json`);
             if (text === undefined)
                 continue;
             try {
                 const v = JSON.parse(text).version;
                 if (typeof v === 'string')
-                    installedVersions.set(t.name, v);
+                    installedVersions.set(target.name, v);
             }
             catch {
                 /* 坏 JSON：当作读不到，由下面的守卫拒掉 */
@@ -705,25 +778,26 @@ export function createPackageManager(deps) {
         // 拒绝而非放行的理由：registry 的 dist-tags.latest 可以**低于**本地已装版本（发布事故后
         // `npm dist-tag add pkg@旧版 latest` 回滚，或用户曾装过预发布版），此时「更新」会静默降级；
         // 读不到已装版本同样拒——无从判断方向就不动，用户可显式卸载重装。
-        const notUpgrade = targets.filter(t => !isUpgrade(installedVersions.get(t.name), t.version));
+        const notUpgrade = targets.filter(target => !isUpgrade(installedVersions.get(target.name), target.version));
         if (notUpgrade.length > 0) {
-            return {
-                ok: false,
-                message: '以下目标版本不高于本地已装版本（或本地版本号读不到），更新会变成降级，已拒绝：' +
-                    notUpgrade
-                        .map(t => `${t.name}（本地 ${installedVersions.get(t.name) ?? '未知'} → 目标 ${t.version}）`)
-                        .join('、'),
-            };
+            const items = notUpgrade.map(({ name, version }) => t('downgradeItem', { name, installed: installedVersions.get(name) ?? t('unknown'), version }));
+            return { ok: false, message: t('notUpgrade', { items }) };
         }
         // ── 预检：整组一次，不逐个 ──
         // 逐个预检发现不了「A@new 要 core>=0.10、B@new 要 core<0.10」这类只在合并时冲突的组合。
         log.info(`更新预检: ${specs.join(' ')}`);
         const reject = (conflicts) => ({
             ok: false,
-            message: '依赖预检未通过，未改动任何文件。若是 peer 版本要求，请把被依赖方一并勾选后重试。',
+            message: t('preflightRejected'),
             conflicts,
         });
-        const verdict = await preflightInSandbox(specs, root);
+        let verdict;
+        try {
+            verdict = await preflightInSandbox(specs, root);
+        }
+        catch (err) {
+            return { ok: false, message: t('preflightFailed', { error: textOf(err) }) };
+        }
         if (verdict)
             return reject(verdict);
         // ── 快照：预检过了才有必要 ──
@@ -756,12 +830,10 @@ export function createPackageManager(deps) {
         // ── 提交 ──
         // 预检在副本里做，live tree 此刻**未被任何 dry-run 触碰**，可以直接装。
         try {
-            await execProc(proc, 'npm', ['install', ...specs, '--no-audit', '--no-fund'], root, INSTALL_TIMEOUT_MS);
+            await npm(['install', ...specs, '--no-audit', '--no-fund'], root, INSTALL_TIMEOUT_MS);
         }
         catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            log.error(`更新安装失败: ${message}`);
-            return { ok: false, message: `安装失败（工程未重启，可重试）: ${message}` };
+            return { ok: false, message: t('installFailedRetry', { error: textOf(err) }) };
         }
         // ── 重启接管 ──
         // 回滚凭据交给重启策略：只有它能观察到「新实例 ready 前夭折」。插件级失败不在此列
@@ -772,19 +844,19 @@ export function createPackageManager(deps) {
         // postRestore 钉**精确旧版**，不用裸 `npm install`。
         // 裸 install 只能按还原后的 package.json 重解析，而声明通常是 caret 范围（`^1.0.0`），
         // 刚崩掉的新版（1.1.0）本身就满足它——于是 npm 又把它装回来，node_modules 分毫未变，
-        // 而重启策略照样打印「已回滚并重新启动旧版本」。实测：有锁时正常，无锁时静默失效。
+        // 而重启策略照样报告已回滚并拉起旧版本。实测：有锁时正常，无锁时静默失效。
         // `--no-save` 保证 package.json 维持 restore 写回的原样，不被 npm 改写成 `^旧版`。
         // 降级守卫已保证每个 target 都有已装版本（读不到的在那里就被拒了），此处的 undefined
         // 过滤只是让类型收窄，不承担逻辑。
         const pinned = targets
-            .map(t => {
-            const v = installedVersions.get(t.name);
-            return v === undefined ? undefined : `${t.name}@${v}`;
+            .map(target => {
+            const v = installedVersions.get(target.name);
+            return v === undefined ? undefined : `${target.name}@${v}`;
         })
             .filter((s) => s !== undefined);
         // 再把「被这次安装顺带改了版本」的包一并钉回旧版（理由见上面 treeBefore 处的注释）。
         // 只回退**本来就在**的包：新增的包钉不回去（它更新前不存在），留给 npm 的 extraneous。
-        const named = new Set(targets.map(t => t.name));
+        const named = new Set(targets.map(target => target.name));
         const treeAfter = await readInstalledTree(deps, root);
         for (const [name, before] of treeBefore) {
             if (named.has(name))
@@ -798,11 +870,11 @@ export function createPackageManager(deps) {
             restore,
             postRestore: { cmd: 'npm', args: ['install', ...pinned, '--no-save', '--no-audit', '--no-fund'], cwd: root },
         });
-        return { ok: true, restarting: true, message: `已更新 ${specs.join('、')}，正在重启…` };
+        return { ok: true, restarting: true, message: t('updated', { specs }) };
     }
     return {
-        update: t => exclusive(`更新 ${t.map(x => x.name).join('、')}`, () => updateAll(t)),
-        install: npmPkg => exclusive(`安装 ${npmPkg}`, async () => {
+        update: targets => exclusive(t('opUpdate', { names: targets.map(x => x.name) }), () => updateAll(targets)),
+        install: npmPkg => exclusive(t('opInstall', { name: npmPkg }), async () => {
             const bad = validatePackageSpec(npmPkg);
             if (bad)
                 return { ok: false, message: bad };
@@ -810,13 +882,13 @@ export function createPackageManager(deps) {
                 return await installTo(npmPkg);
             }
             catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                log.error(`安装 "${npmPkg}" 失败: ${message}`);
+                const message = textOf(err);
+                log.error(`安装 "${npmPkg}" 失败: ${toSource(message)}`);
                 return { ok: false, message };
             }
         }),
-        uninstall: pluginName => exclusive(`卸载 ${pluginName}`, () => uninstallOne(pluginName)),
-        serviceDependents: name => findServiceDependents(name, deps.pluginStatus?.() ?? []),
+        uninstall: (pluginName, options) => exclusive(t('opUninstall', { name: pluginName }), () => uninstallOne(pluginName, options)),
+        serviceDependents: name => findServiceDependents(name, deps.pluginStatus?.() ?? [], deps.availableServices?.() ?? []),
         registry,
     };
     /**
@@ -826,14 +898,14 @@ export function createPackageManager(deps) {
      * （与 `buildUpdateSpecs`、`isRegistryDep` 同一理由）。前端早就有正确策略
      * （只给 plugin/interface 卡片渲染卸载按钮），但那只是客户端校验，服务端不设防。
      */
-    async function uninstallOne(pluginName) {
+    async function uninstallOne(pluginName, { removeConfig = false } = {}) {
         const bad = validatePackageSpec(pluginName);
         if (bad)
             return { ok: false, message: bad };
         const root = deps.projectRoot();
         const meta = await readJson(`${root}/node_modules/${pluginName}/package.json`);
         if (!meta) {
-            return { ok: false, message: `读不到 ${pluginName} 的 package.json，无法确认它是什么，已拒绝卸载` };
+            return { ok: false, message: t('noPackageJson', { name: pluginName }) };
         }
         // ── 闸一：类型 ──
         // 市场管的是**插件**。core / runtime / api / schema / util 不是插件，不在本工具职权内。
@@ -846,10 +918,10 @@ export function createPackageManager(deps) {
         if (kind) {
             return {
                 ok: false,
-                message: `${pluginName} 是${kind}，不是可装卸的插件，市场不负责它的卸载。` +
-                    (kind === '内核' || kind === '宿主'
-                        ? '删掉它实例将无法启动、市场也随之消失，只能在终端里恢复；确需如此请手动执行 npm uninstall。'
-                        : '它随依赖它的插件被 npm 自动剪枝；确需单独删除请手动执行 npm uninstall。'),
+                message: t(kind === 'core' || kind === 'runtime' ? 'uninstallVital' : 'uninstallPruned', {
+                    name: pluginName,
+                    kind: KIND_NAMES[kind],
+                }),
             };
         }
         // ── 闸一之二：承载「撤销通道」的服务提供者不能被卸掉 ──
@@ -866,27 +938,23 @@ export function createPackageManager(deps) {
         // 那时它已不是提供者，本闸自然放行。
         const lifeline = deps.recoveryChannelProviders?.() ?? [];
         if (lifeline.includes(pluginName)) {
-            return {
-                ok: false,
-                message: `${pluginName} 正在承载市场/管理界面本身，卸掉它这个页面会立刻不可用，` +
-                    '只能在终端里恢复。若确要更换实现，请先装上替代者并在「服务」页切换过去，再回来卸载它。',
-            };
+            return { ok: false, message: t('lifeline', { name: pluginName }) };
         }
         // ── 闸二：来源 ──
         // 只有根依赖里以 semver 范围声明的才归市场管。workspace: 是用户自己的源码（删了不可逆，
         // 且多半在 git 里）；file:/link: 指向本地目录；git/URL 是外部源；不在根依赖里的是传递依赖。
         const rootPkg = await readJson(`${root}/package.json`);
         const request = (rootPkg?.dependencies ?? {})[pluginName];
-        if (!isRegistryDep(request)) {
-            const origin = classifyDepSpec(request);
+        const origin = classifyDepSpec(request);
+        if (origin !== 'registry') {
             const why = {
-                workspace: '它是工作区里的本地源码包，删除请走 git',
-                link: '它由 file:/link: 指向本地目录，删除请改那份源码与依赖声明',
-                git: '它由 git/URL/user-repo 简写安装，删除请改依赖声明',
-                alias: '它由 npm: 别名指向另一个包，删除请改依赖声明',
-                transitive: '它不在根依赖里（由其它插件带入），会随带入它的插件被 npm 自动剪枝',
+                workspace: t('originWorkspace'),
+                link: t('originLink'),
+                git: t('originGit'),
+                alias: t('originAlias'),
+                transitive: t('originTransitive'),
             };
-            return { ok: false, message: `${pluginName} 不是经市场安装的：${why[origin] ?? '来源不明'}。` };
+            return { ok: false, message: t('notFromMarket', { name: pluginName, why: why[origin] }) };
         }
         // 先解析定义 name 并枚举实例：npm uninstall 会拆掉 node_modules，之后就读不到入口了。
         const defName = await definitionNameFor(pluginName);
@@ -894,39 +962,47 @@ export function createPackageManager(deps) {
         // ── 闸三：服务依赖者 ──
         // 某服务没有别的插件正在提供时，卸掉它的提供者会打断 required 该服务的插件（已禁用的不算）。
         // 与市场卸载前的预警同一份判定（serviceDependents），按加载器解析出的定义 name 查。
-        const dependents = findServiceDependents(defName, deps.pluginStatus?.() ?? []);
+        const dependents = findServiceDependents(defName, deps.pluginStatus?.() ?? [], deps.availableServices?.() ?? []);
         if (dependents.length > 0) {
-            return {
-                ok: false,
-                message: `卸载会破坏依赖：${dependents.join('、')} 依赖此插件提供的服务，且没有别的插件正在提供。请先停用它们，或启用 / 安装替代提供者。`,
-            };
+            return { ok: false, message: t('breaksDependents', { dependents }) };
         }
         try {
-            await execProc(proc, 'npm', ['uninstall', pluginName, '--no-audit', '--no-fund'], root, INSTALL_TIMEOUT_MS);
-            for (const id of instanceIds) {
-                await deps.unloadPlugin(id); // 从运行时注册表彻底移除（dispose + delete），幂等
-                deps.cleanupConfig?.(id); // 清残留配置（含禁用标记）
-            }
-            log.info(`${pluginName}: 已从根依赖与 node_modules 移除`);
+            await npm(['uninstall', pluginName, '--no-audit', '--no-fund'], root, INSTALL_TIMEOUT_MS);
+            // 从运行时注册表彻底移除（dispose + delete），幂等
+            for (const id of instanceIds)
+                await deps.unloadPlugin(id);
+        }
+        catch (err) {
+            return { ok: false, message: textOf(err) };
+        }
+        log.info(`${pluginName}: 已从根依赖与 node_modules 移除`);
+        // 包已经卸掉了，配置文件没写成不改变这一点：回执照样 ok，写明原因与残留
+        try {
+            await deps.cleanupConfig?.(instanceIds, removeConfig);
+        }
+        catch (err) {
             return {
                 ok: true,
-                message: `插件 ${pluginName} 已卸载（已从根依赖与 node_modules 移除）。它写入 data/ 等存储根的数据不会删除，需要时请手动清理。`,
+                message: t(removeConfig ? 'uninstalledConfigUnsaved' : 'uninstalledFlagUnsaved', {
+                    name: pluginName,
+                    error: textOf(err),
+                }),
             };
         }
-        catch (err) {
-            return { ok: false, message: err instanceof Error ? err.message : String(err) };
-        }
+        return {
+            ok: true,
+            message: t(removeConfig ? 'uninstalledConfigRemoved' : 'uninstalledConfigKept', { name: pluginName }),
+        };
     }
 }
 export default definePlugin({
     name: '@aalis/plugin-package-manager',
-    displayName: '包管理器',
+    displayName: t('displayName'),
     subsystem: 'system',
-    configSchema,
     provides: [packageManager],
     uses,
     apply(caps) {
-        caps.provide(packageManager, createService(caps), { label: 'package-manager' });
+        caps.provide.use(packageManager, createService(caps), { label: 'package-manager' });
     },
 });
 //# sourceMappingURL=index.js.map