dsh-config-manager 0.1.71 → 0.1.73

package/lib/market/my-repo.js

@@ -34,13 +34,16 @@ import { MARKET_INDEX_SCHEMA_VERSION } from './types.js';
 import { stringifyJsonSafe } from '../utils/json.js';
 import { sha256Hex } from '../utils/hashing.js';
 import { redact } from '../security/redaction.js';
+import { marketMsg } from './messages-market.js';
 /* ---------------------------------------------------------------- 常量（固定规则，无配置入口） */
 /** 官方收录目标仓库原样复用 t1 常量（github-repos.ts）
  *  —— 与内置市场同一仓库，界面不提供任何修改入口（设计 §2.4 产品决策）。 */
 /** 用户公开仓库固定名：<login>/dsh-configs（系统按规则生成，不可配置） */
 export const USER_CONFIGS_REPO = 'dsh-configs';
-/** 用户仓库 index.json 的名称/描述（展示用） */
-export const USER_INDEX_NAME = '我的配置仓库';
+/** 用户仓库 index.json 的名称/描述（展示用；按当前界面语言在**取用时**解析，不冻结在模块加载期） */
+export function userIndexName() {
+    return marketMsg('market.myRepo.indexName');
+}
 /** PR 分支固定名模式：dsh-market-sync/<itemId>（收录） */
 export const PR_BRANCH_PREFIX = 'dsh-market-sync';
 /** 下架 PR 分支固定名模式：dsh-market-delist/<itemId>（删除已收录条目；独立分支避免与收录分支混淆，
@@ -101,7 +104,7 @@ export function bumpVersion(version) {
 }
 /** 空用户索引（首次上传时创建） */
 function emptyIndex() {
-    return { schemaVersion: MARKET_INDEX_SCHEMA_VERSION, name: USER_INDEX_NAME, items: [] };
+    return { schemaVersion: MARKET_INDEX_SCHEMA_VERSION, name: userIndexName(), items: [] };
 }
 /** upsert 条目：同 id 覆盖（保持原位置），否则追加 */
 function upsertIndexItem(index, item) {
@@ -168,10 +171,10 @@ export class MyRepoService {
     loginWriteQueues = new Map();
     constructor(options) {
         if (options.prepare === null || typeof options.prepare !== 'function') {
-            throw new MyRepoError('prepare 必填');
+            throw new MyRepoError(marketMsg('market.myRepo.prepareRequired'));
         }
         if (options.rest === null || typeof options.rest !== 'object') {
-            throw new MyRepoError('rest 必填');
+            throw new MyRepoError(marketMsg('market.myRepo.restRequired'));
         }
         this.prepare = options.prepare;
         this.rest = options.rest;
@@ -197,7 +200,7 @@ export class MyRepoService {
             return []; // 从未上传
         const parsed = parseMarketIndex(indexText);
         if (!parsed.ok || parsed.index === null) {
-            throw new MyRepoError('用户仓库 index.json 无法解析（可能被外部修改）', 'index_invalid');
+            throw new MyRepoError(marketMsg('market.myRepo.userIndexUnparsable'), 'index_invalid');
         }
         // 收录状态：官方 index 含该 id → listed；否则按设计 §4.5 以 head=<login>:<branch>
         // 过滤 open PR（避免跨用户同名分支误报）→ pr-pending；否则 not-listed
@@ -284,7 +287,7 @@ export class MyRepoService {
         const { index } = await this.readUserIndex(login);
         const item = index.items.find((it) => it.id === itemId);
         if (item === undefined) {
-            throw new MyRepoError(`未找到条目 ${itemId}（可能已被删除），请刷新列表后重试`, 'item_not_found');
+            throw new MyRepoError(marketMsg('market.myRepo.itemNotFound', { itemId }), 'item_not_found');
         }
         const repoUrl = userConfigsRepoUrl(login);
         this.launchListing({
@@ -305,7 +308,7 @@ export class MyRepoService {
             if (job !== undefined && job.status !== 'pending')
                 return this.toListingStatus(job);
             if (Date.now() >= deadline) {
-                throw new MyRepoError(`等待市场任务超时（${itemId}）`, 'internal');
+                throw new MyRepoError(marketMsg('market.myRepo.listingTimeout', { itemId }), 'internal');
             }
             await new Promise((resolve) => setTimeout(resolve, 25));
         }
@@ -329,7 +332,7 @@ export class MyRepoService {
             const { index } = await this.readUserIndex(login);
             const item = index.items.find((it) => it.id === itemId);
             if (item === undefined) {
-                throw new MyRepoError(`未找到要删除的条目 ${itemId}（可能已被删除），请刷新列表后重试`, 'item_not_found');
+                throw new MyRepoError(marketMsg('market.myRepo.itemToDeleteNotFound', { itemId }), 'item_not_found');
             }
             // ② 移除条目 + 删除 items/<itemId>/ 目录 → 写回 index.json（per-login 串行）
             const updatedIndex = removeIndexItem(index, itemId);
@@ -367,7 +370,7 @@ export class MyRepoService {
                     delisted: true,
                     prNumber: null,
                     prUrl: null,
-                    warnings: ['该条目已收录官方市场，已自动提交下架 PR；合并前官方市场可能仍显示该条目'],
+                    warnings: [marketMsg('market.myRepo.delistPrSubmitted')],
                 };
             }
             // 未收录 → 关闭待审核的收录 PR（如有）
@@ -381,7 +384,7 @@ export class MyRepoService {
                     delisted: false,
                     prNumber: pr.number,
                     prUrl: pr.htmlUrl,
-                    warnings: ['已关闭该条目的待审核收录 PR'],
+                    warnings: [marketMsg('market.myRepo.pendingPrClosed')],
                 };
             }
             return { ok: true, itemId, delisted: false, prNumber: null, prUrl: null, warnings: [] };
@@ -429,12 +432,12 @@ export class MyRepoService {
                 }
                 else if (explicitId !== null) {
                     // 明确要求更新一个不存在的 id → 报错（避免静默新建导致用户以为更新成功）
-                    throw new MyRepoError(`未找到要更新的条目 ${explicitId}（可能已被移除），请刷新列表后重试`, 'item_not_found');
+                    throw new MyRepoError(marketMsg('market.myRepo.itemToUpdateNotFound', { itemId: explicitId }), 'item_not_found');
                 }
                 else {
                     itemId = uniqueItemId(baseId, ids); // 名称变化 → 作为新条目
                     version = '1.0.0';
-                    warnings.push('未找到同名已上传条目，名称变化将作为新条目发布');
+                    warnings.push(marketMsg('market.myRepo.nameChangedNewItem'));
                 }
             }
             else {
@@ -509,7 +512,7 @@ export class MyRepoService {
             return { index: emptyIndex(), exists: false };
         const parsed = parseMarketIndex(text);
         if (!parsed.ok || parsed.index === null) {
-            throw new MyRepoError('用户仓库 index.json 无法解析（可能被外部修改），已中止，请检查后重试', 'index_invalid');
+            throw new MyRepoError(marketMsg('market.myRepo.userIndexUnparsableAborted'), 'index_invalid');
         }
         return { index: parsed.index, exists: true };
     }
@@ -517,11 +520,11 @@ export class MyRepoService {
     async readOfficialIndex() {
         const text = await this.rest.readFile(MARKET_UPSTREAM_OWNER, MARKET_UPSTREAM_REPO, 'index.json');
         if (text === null) {
-            throw new MyRepoError('官方市场 index.json 不存在', 'official_index_missing');
+            throw new MyRepoError(marketMsg('market.myRepo.officialIndexMissing'), 'official_index_missing');
         }
         const parsed = parseMarketIndex(text);
         if (!parsed.ok || parsed.index === null) {
-            throw new MyRepoError('官方市场 index.json 无法解析', 'official_index_invalid');
+            throw new MyRepoError(marketMsg('market.myRepo.officialIndexUnparsable'), 'official_index_invalid');
         }
         return { index: parsed.index };
     }
@@ -529,7 +532,7 @@ export class MyRepoService {
     parsePreparedManifest(manifestText) {
         const parsed = parseMarketItemManifest(manifestText);
         if (!parsed.ok || parsed.manifest === null) {
-            throw new MyRepoError('prepare 生成的 manifest 无效', 'internal');
+            throw new MyRepoError(marketMsg('market.myRepo.preparedManifestInvalid'), 'internal');
         }
         return parsed.manifest;
     }
@@ -546,7 +549,7 @@ export class MyRepoService {
                 fork: false,
             };
         }
-        return this.rest.createPublicRepo(USER_CONFIGS_REPO, '我的配置仓库（dsh-config-manager 自动发布）');
+        return this.rest.createPublicRepo(USER_CONFIGS_REPO, marketMsg('market.myRepo.repoDescription'));
     }
     /** ⑨ ensure PR：open PR（head=<login>:<branch>）存在 → 复用；否则 openPullRequest(base=main)。
      *  action='delist' 时标题/正文为下架语义（分支用 delistBranchFor，head 过滤天然隔离）。 */
@@ -559,26 +562,26 @@ export class MyRepoService {
             return this.rest.openPullRequest({
                 head,
                 base: 'main',
-                title: `市场下架：${itemId}`,
+                title: marketMsg('market.myRepo.delistPrTitle', { itemId }),
                 body: [
-                    `由 dsh-config-manager「删除条目」自动提交。`,
+                    marketMsg('market.myRepo.delistPrIntro'),
                     '',
-                    `- 条目：${itemId}`,
-                    `- 操作：从官方市场 index.json 移除该条目（下架）`,
-                    `- 内容：原条目内容位于用户公开仓库，已随删除移除`,
+                    marketMsg('market.myRepo.delistPrItemLine', { itemId }),
+                    marketMsg('market.myRepo.delistPrAction'),
+                    marketMsg('market.myRepo.delistPrContent'),
                 ].join('\n'),
             });
         }
         return this.rest.openPullRequest({
             head,
             base: 'main',
-            title: `市场收录：${itemId} v${version}`,
+            title: marketMsg('market.myRepo.listPrTitle', { itemId, version }),
             body: [
-                `由 dsh-config-manager「一键上传」自动提交。`,
+                marketMsg('market.myRepo.listPrIntro'),
                 '',
-                `- 条目：${itemId} v${version}`,
-                `- 内容托管：用户公开仓库（见 index.json 条目 repo 字段）`,
-                `- 校验：dsh-config-market CI（validate.yml）将自动执行 8 道校验与秘密扫描`,
+                marketMsg('market.myRepo.listPrItemLine', { itemId, version }),
+                marketMsg('market.myRepo.listPrHosting'),
+                marketMsg('market.myRepo.listPrValidation'),
             ].join('\n'),
         });
     }
@@ -626,7 +629,7 @@ export class MyRepoService {
             const { index } = await this.readUserIndex(job.login);
             const item = index.items.find((it) => it.id === job.itemId);
             if (item === undefined) {
-                throw new MyRepoError(`条目 ${job.itemId} 已不在用户仓库（可能已删除），任务终止`, 'item_not_found');
+                throw new MyRepoError(marketMsg('market.myRepo.itemGoneFromUserRepo', { itemId: job.itemId }), 'item_not_found');
             }
             updatedOfficial = upsertIndexItem(officialIndex.index, { ...item, repo: job.repoUrl });
             commitMsg = `market: ${item.version !== undefined && item.version !== '' ? 'update' : 'add'} ${job.itemId} v${job.version}`;

package/lib/market/prepare.js

@@ -19,6 +19,7 @@ import { sectionMeta } from '../schema/section-registry.js';
 import { scanAndRedact, scanText } from '../security/secret-scanner.js';
 import { validateMarketRepoUrl } from './url.js';
 import { assertSafeItemId, BANNED_MARKET_SECTIONS, MARKET_ITEM_SCHEMA_VERSION, MAX_MARKET_ZIP_BYTES, } from './types.js';
+import { marketMsg } from './messages-market.js';
 export class MarketPrepareError extends Error {
     constructor(message) {
         super(message);
@@ -38,19 +39,19 @@ export function prepareMarketItem(input) {
     // 1. id / name 基础校验
     assertSafeItemId(input.itemId);
     if (typeof input.name !== 'string' || input.name.trim() === '') {
-        throw new MarketPrepareError('name 必填');
+        throw new MarketPrepareError(marketMsg('market.prepare.nameRequired'));
     }
     // 2. repoUrl 可选校验（强制 http(s)，拒绝 userinfo / git@/ssh；非法即拒绝发布）
     const repoUrl = typeof input.repoUrl === 'string' && input.repoUrl.trim() !== '' ? input.repoUrl.trim() : undefined;
     if (repoUrl !== undefined) {
         const err = validateMarketRepoUrl(repoUrl);
         if (err !== null)
-            throw new MarketPrepareError(`repoUrl 非法: ${err}`);
+            throw new MarketPrepareError(marketMsg('market.prepare.repoUrlInvalid', { reason: err }));
     }
     // 3. zip 体积上限（zip bomb 首道闸，与 security.ts 一致）
     const buf = Buffer.isBuffer(input.zipBytes) ? input.zipBytes : Buffer.from(input.zipBytes);
     if (buf.length > MAX_MARKET_ZIP_BYTES) {
-        throw new MarketPrepareError(`config.zip 体积 ${buf.length} 超过上限 ${MAX_MARKET_ZIP_BYTES} 字节`);
+        throw new MarketPrepareError(marketMsg('market.prepare.zipTooLarge', { size: buf.length, max: MAX_MARKET_ZIP_BYTES }));
     }
     // 4. 加固解包（Zip Slip / 绝对路径 / 恶意条目；异常 → 拒绝）
     let archive;
@@ -58,39 +59,39 @@ export function prepareMarketItem(input) {
         archive = parseZipHardened(buf);
     }
     catch (err) {
-        throw new MarketPrepareError(`config.zip 安全解析失败: ${err instanceof Error ? err.message : String(err)}`);
+        throw new MarketPrepareError(marketMsg('market.prepare.zipParseFailed', { reason: err instanceof Error ? err.message : String(err) }));
     }
     // 5. 内部 manifest + secrets 硬约束
     if (!archive.has(MANIFEST_FILE)) {
-        throw new MarketPrepareError('config.zip 缺少内部 manifest.json（须为导出/备份格式）');
+        throw new MarketPrepareError(marketMsg('market.prepare.zipMissingManifest'));
     }
     let internalManifest;
     try {
         internalManifest = parseManifest(archive.readEntryText(MANIFEST_FILE));
     }
     catch (err) {
-        throw new MarketPrepareError(`config.zip 内部 manifest 无效: ${err instanceof Error ? err.message : String(err)}`);
+        throw new MarketPrepareError(marketMsg('market.prepare.zipManifestInvalid', { reason: err instanceof Error ? err.message : String(err) }));
     }
     if (internalManifest.security.containsSecrets) {
-        throw new MarketPrepareError('zip 声明 containsSecrets=true，市场通道永不携带秘密，拒绝发布');
+        throw new MarketPrepareError(marketMsg('market.prepare.zipContainsSecrets'));
     }
     // 6. sections = 内部 manifest 启用的分区（空 → 无可发布内容）
     const sections = Object.entries(internalManifest.sections)
         .filter(([, on]) => on)
         .map(([id]) => id);
     if (sections.length === 0) {
-        throw new MarketPrepareError('zip 无启用分区，无可发布内容');
+        throw new MarketPrepareError(marketMsg('market.prepare.zipNoSections'));
     }
     // 6b. 市场条目禁止分区（BANNED_MARKET_SECTIONS：sessions 历史会话 / pluginFiles 任意文件 / self 本地环境）
     const bannedHit = sections.filter((s) => BANNED_MARKET_SECTIONS.includes(s));
     if (bannedHit.length > 0) {
-        throw new MarketPrepareError(`zip 包含禁止分区 ${bannedHit.join(', ')}（sessions=历史会话 / pluginFiles=任意文件 / self=本地环境），市场条目禁止携带`);
+        throw new MarketPrepareError(marketMsg('market.prepare.bannedSections', { sections: bannedHit.join(', ') }));
     }
     // 6b2. 分享模式额外排除：deviceSpecific/platformSpecific 分区（比 BANNED 更严，与 BANNED 同语义——直接拒绝）
     if (isShare) {
         const nonPortable = sections.filter((s) => sectionMeta(s).portability !== 'portable');
         if (nonPortable.length > 0) {
-            throw new MarketPrepareError(`分享模式禁止携带设备/平台相关分区 ${nonPortable.join(', ')}（含凭据状态 / 会话 / MCP / 工作区等），请仅导出通用可移植分区`);
+            throw new MarketPrepareError(marketMsg('market.prepare.shareNonPortableSections', { sections: nonPortable.join(', ') }));
         }
     }
     // 6b3. T1：plugins 分区禁止携带本地插件 tarball（localTarballs）。
@@ -103,12 +104,12 @@ export function prepareMarketItem(input) {
             : null;
         const tb = pluginsJson?.localTarballs;
         if (Array.isArray(tb) && tb.length > 0) {
-            throw new MarketPrepareError(`zip 的 plugins 分区携带 ${tb.length} 个本地插件 tarball（localTarballs），禁止发布到市场（内嵌插件代码不可经公开仓库审阅；本地插件迁移请用自己的备份）`);
+            throw new MarketPrepareError(marketMsg('market.prepare.localTarballsRejected', { count: tb.length }));
         }
         // issue #35：patchFiles 同类拒绝（patch 在安装时改写依赖代码，同样不可经公开仓库审阅）
         const pfs = pluginsJson?.patchFiles;
         if (Array.isArray(pfs) && pfs.length > 0) {
-            throw new MarketPrepareError(`zip 的 plugins 分区携带 ${pfs.length} 个 pnpm patch 文件（patchFiles），禁止发布到市场（会在安装时改写依赖代码；请用自己的备份迁移）`);
+            throw new MarketPrepareError(marketMsg('market.prepare.patchFilesRejected', { count: pfs.length }));
         }
     }
     // 6c. 内容级秘密扫描（纵深防御，不依赖导出 containsSecrets 标记）：
@@ -152,7 +153,9 @@ export function prepareMarketItem(input) {
     if (scanHits.length > 0) {
         const limit = isShare ? 10 : 3;
         const suffix = scanHits.length > limit ? '…' : '';
-        throw new MarketPrepareError(`检测到疑似敏感内容（${scanHits.slice(0, limit).join('；')}${suffix}），市场条目禁止携带凭据，请脱敏后重试`);
+        throw new MarketPrepareError(marketMsg('market.prepare.sensitiveContent', {
+            hits: scanHits.slice(0, limit).join(marketMsg('market.prepare.scanHitSeparator')) + suffix,
+        }));
     }
     // 7. SHA-256 + 生成 L2 manifest
     const sha256 = sha256Hex(buf);
@@ -178,8 +181,8 @@ export function prepareMarketItem(input) {
         sha256,
         sections,
         warnings: [
-            '条目将发布至公共网络市场，未经官方审核（供应链警示）',
-            '发布内容为不可信输入，下载方导入前会逐项核对',
+            marketMsg('market.prepare.warningPublicMarket'),
+            marketMsg('market.prepare.warningUntrustedInput'),
         ],
     };
 }

package/lib/market/security.js

@@ -16,6 +16,7 @@ import { parseManifest, CHECKSUMS_FILE, MANIFEST_FILE } from '../schema/manifest
 import { validateSectionData, SECTION_JSON_PATHS, SECTION_FILE_PREFIXES, isFileSection } from '../schema/config.js';
 import { parseMarketItemManifest } from './index-parser.js';
 import { MAX_MARKET_ZIP_BYTES, BANNED_MARKET_SECTIONS } from './types.js';
+import { marketMsg } from './messages-market.js';
 // 限额唯一来源 = utils/zip.ts 的 DEFAULT_ZIP_SAFETY_LIMITS（此处曾复制一份字面量，纯冗余）：
 // 不传 defaultLimits → 与默认解析路径、读侧上限逐项一致。
 const parseZipHardened = createHardenedZipParser();
@@ -36,17 +37,17 @@ export function validateMarketItem(itemId, manifestRaw, zipBytes) {
     }
     const manifest = parsedManifest.manifest;
     if (manifest.id !== itemId) {
-        return { status: 'invalid', errors: [`清单 id 与请求条目不一致: ${manifest.id} ≠ ${itemId}`], warnings, manifest, internalManifest: null, sections: [], checksumsOk: false };
+        return { status: 'invalid', errors: [marketMsg('market.security.manifestIdMismatch', { manifestId: manifest.id, itemId })], warnings, manifest, internalManifest: null, sections: [], checksumsOk: false };
     }
     const buf = Buffer.isBuffer(zipBytes) ? zipBytes : Buffer.from(zipBytes);
     // 2. 字节体积上限（zip bomb 首道闸）
     if (buf.length > MAX_MARKET_ZIP_BYTES) {
-        return { status: 'invalid', errors: [`config.zip 体积 ${buf.length} 超过上限 ${MAX_MARKET_ZIP_BYTES} 字节`], warnings, manifest, internalManifest: null, sections: [], checksumsOk: false };
+        return { status: 'invalid', errors: [marketMsg('market.security.zipTooLarge', { size: buf.length, max: MAX_MARKET_ZIP_BYTES })], warnings, manifest, internalManifest: null, sections: [], checksumsOk: false };
     }
     // 3. L2↔L3 一致性：清单声明的 config.zip SHA-256 与实际一致
     const actualSha = sha256Hex(buf);
     if (manifest.checksums.zip !== actualSha) {
-        return { status: 'invalid', errors: [`清单声明的 config.zip SHA-256 与实际不符`], warnings, manifest, internalManifest: null, sections: [], checksumsOk: false };
+        return { status: 'invalid', errors: [marketMsg('market.security.zipShaMismatch')], warnings, manifest, internalManifest: null, sections: [], checksumsOk: false };
     }
     // 4. Zip 加固解包（Zip Slip / 绝对路径 / 恶意条目 / 重复 / symlink；异常 → 拒绝整包）
     let archive;
@@ -54,21 +55,21 @@ export function validateMarketItem(itemId, manifestRaw, zipBytes) {
         archive = parseZipHardened(buf);
     }
     catch (err) {
-        return { status: 'invalid', errors: [`config.zip 安全解析失败: ${err instanceof Error ? err.message : String(err)}`], warnings, manifest, internalManifest: null, sections: [], checksumsOk: false };
+        return { status: 'invalid', errors: [marketMsg('market.security.zipParseFailed', { reason: err instanceof Error ? err.message : String(err) })], warnings, manifest, internalManifest: null, sections: [], checksumsOk: false };
     }
     // 5. 内部 manifest + 分区校验
     if (!archive.has(MANIFEST_FILE)) {
-        return { status: 'invalid', errors: ['config.zip 缺少内部 manifest.json'], warnings, manifest, internalManifest: null, sections: [], checksumsOk: false };
+        return { status: 'invalid', errors: [marketMsg('market.security.zipMissingManifest')], warnings, manifest, internalManifest: null, sections: [], checksumsOk: false };
     }
     let internalManifest;
     try {
         internalManifest = parseManifest(archive.readEntryText(MANIFEST_FILE));
     }
     catch (err) {
-        return { status: 'invalid', errors: [`config.zip 内部 manifest 无效: ${err instanceof Error ? err.message : String(err)}`], warnings, manifest, internalManifest: null, sections: [], checksumsOk: false };
+        return { status: 'invalid', errors: [marketMsg('market.security.zipManifestInvalid', { reason: err instanceof Error ? err.message : String(err) })], warnings, manifest, internalManifest: null, sections: [], checksumsOk: false };
     }
     if (internalManifest.security.containsSecrets) {
-        return { status: 'invalid', errors: ['config.zip 声明 containsSecrets=true，市场通道永不携带秘密，拒绝'], warnings, manifest, internalManifest, sections: [], checksumsOk: false };
+        return { status: 'invalid', errors: [marketMsg('market.security.zipContainsSecrets')], warnings, manifest, internalManifest, sections: [], checksumsOk: false };
     }
     // 6. 内部 checksum 校验（integrity/checksums.json ↔ 实际条目）
     let checksumsOk = false;
@@ -89,11 +90,11 @@ export function validateMarketItem(itemId, manifestRaw, zipBytes) {
             const result = verifyChecksums(entries, table);
             checksumsOk = result.ok;
             if (!checksumsOk) {
-                return { status: 'invalid', errors: [`config.zip 内部完整性校验失败: ${[...result.mismatches, ...result.missing].join(', ')}`], warnings, manifest, internalManifest, sections: [], checksumsOk: false };
+                return { status: 'invalid', errors: [marketMsg('market.security.checksumMismatch', { entries: [...result.mismatches, ...result.missing].join(', ') })], warnings, manifest, internalManifest, sections: [], checksumsOk: false };
             }
         }
         catch (err) {
-            return { status: 'invalid', errors: [`config.zip 内部 checksums 解析失败: ${err instanceof Error ? err.message : String(err)}`], warnings, manifest, internalManifest, sections: [], checksumsOk: false };
+            return { status: 'invalid', errors: [marketMsg('market.security.checksumsParseFailed', { reason: err instanceof Error ? err.message : String(err) })], warnings, manifest, internalManifest, sections: [], checksumsOk: false };
         }
     }
     // 7. 内部分区数据校验（JSON 分区逐一 validateSectionData）
@@ -103,7 +104,7 @@ export function validateMarketItem(itemId, manifestRaw, zipBytes) {
         // 市场条目禁止分区（BANNED_MARKET_SECTIONS：sessions 历史会话 / pluginFiles 任意文件 / self 本地环境）：
         // 与 secrets 同级硬约束（产品决策 2026-08-19，guide docs/design/2026-08-19-market-repo-setup-guide.md）。
         if (BANNED_MARKET_SECTIONS.includes(sectionId)) {
-            return { status: 'invalid', errors: [`config.zip 包含禁止分区 ${sectionId}（sessions=历史会话 / pluginFiles=任意文件 / self=本地环境），市场条目禁止携带`], warnings, manifest, internalManifest, sections: [], checksumsOk: true };
+            return { status: 'invalid', errors: [marketMsg('market.security.bannedSection', { section: sectionId })], warnings, manifest, internalManifest, sections: [], checksumsOk: true };
         }
         if (isFileSection(sectionId)) {
             // 文件类分区：以文件形式进入 ZIP，结构校验由 security/safeExtract 在导入期做。
@@ -112,7 +113,7 @@ export function validateMarketItem(itemId, manifestRaw, zipBytes) {
             // 与 sync 通道对空分区的语义一致（空分区参与 manifest 标记但不产生任何文件）。
             // 仅加 warning 提示，不拒绝；JSON 分区仍严格要求文件存在（有内容才可能 enabled）。
             if (!archive.names().some((n) => n.startsWith(SECTION_FILE_PREFIXES[sectionId]))) {
-                warnings.push(`config.zip 中分区 ${sectionId} 为空（无文件），导入后不产生任何效果`);
+                warnings.push(marketMsg('market.security.emptyFileSection', { section: sectionId }));
             }
             continue;
         }
@@ -120,19 +121,19 @@ export function validateMarketItem(itemId, manifestRaw, zipBytes) {
         if (jsonPath === undefined)
             continue;
         if (!archive.has(jsonPath)) {
-            return { status: 'invalid', errors: [`config.zip 缺少分区文件 ${jsonPath}（${sectionId}）`], warnings, manifest, internalManifest, sections: [], checksumsOk: true };
+            return { status: 'invalid', errors: [marketMsg('market.security.missingSectionFile', { path: jsonPath, section: sectionId })], warnings, manifest, internalManifest, sections: [], checksumsOk: true };
         }
         let data;
         try {
             data = archive.readEntryJson(jsonPath);
         }
         catch (err) {
-            return { status: 'invalid', errors: [`分区 ${sectionId} 数据解析失败: ${err instanceof Error ? err.message : String(err)}`], warnings, manifest, internalManifest, sections: [], checksumsOk: true };
+            return { status: 'invalid', errors: [marketMsg('market.security.sectionParseFailed', { section: sectionId, reason: err instanceof Error ? err.message : String(err) })], warnings, manifest, internalManifest, sections: [], checksumsOk: true };
         }
         const issues = validateSectionData(sectionId, data);
         const hardErrors = issues.filter((i) => i.severity === 'error');
         if (hardErrors.length > 0) {
-            return { status: 'invalid', errors: [`分区 ${sectionId} 数据无效: ${hardErrors.map((e) => e.message).join('; ')}`], warnings, manifest, internalManifest, sections: [], checksumsOk: true };
+            return { status: 'invalid', errors: [marketMsg('market.security.sectionInvalid', { section: sectionId, errors: hardErrors.map((e) => e.message).join('; ') })], warnings, manifest, internalManifest, sections: [], checksumsOk: true };
         }
         // T1 供应链约束：plugins 分区禁止携带本地插件 tarball（localTarballs）。
         //
@@ -146,7 +147,7 @@ export function validateMarketItem(itemId, manifestRaw, zipBytes) {
             if (Array.isArray(tarballs) && tarballs.length > 0) {
                 return {
                     status: 'invalid',
-                    errors: [`config.zip 的 plugins 分区携带 ${tarballs.length} 个本地插件 tarball（localTarballs），市场条目禁止携带内嵌插件代码（供应链防线；本地插件迁移请用自己的备份，不要经公共市场分发）`],
+                    errors: [marketMsg('market.security.localTarballsRejected', { count: tarballs.length })],
                     warnings, manifest, internalManifest, sections: [], checksumsOk: true,
                 };
             }
@@ -156,7 +157,7 @@ export function validateMarketItem(itemId, manifestRaw, zipBytes) {
             if (Array.isArray(patchFiles) && patchFiles.length > 0) {
                 return {
                     status: 'invalid',
-                    errors: [`config.zip 的 plugins 分区携带 ${patchFiles.length} 个 pnpm patch 文件（patchFiles），市场条目禁止携带会在安装时改写依赖代码的内容（供应链防线；请用自己的备份迁移）`],
+                    errors: [marketMsg('market.security.patchFilesRejected', { count: patchFiles.length })],
                     warnings, manifest, internalManifest, sections: [], checksumsOk: true,
                 };
             }
@@ -169,7 +170,7 @@ export function validateMarketItem(itemId, manifestRaw, zipBytes) {
         .map(([id]) => id);
     const intersection = l3Sections.filter((id) => l2Sections.has(id));
     if (intersection.length === 0) {
-        return { status: 'invalid', errors: ['清单 sections 与 config.zip 内部 sections 无交集'], warnings, manifest, internalManifest, sections: [], checksumsOk: true };
+        return { status: 'invalid', errors: [marketMsg('market.security.sectionsNoIntersection')], warnings, manifest, internalManifest, sections: [], checksumsOk: true };
     }
     return { status: 'valid', errors: [], warnings, manifest, internalManifest, sections: intersection, checksumsOk };
 }
@@ -179,8 +180,8 @@ export function validateMarketItem(itemId, manifestRaw, zipBytes) {
  */
 export function generateSupplyChainWarnings(itemId) {
     return [
-        `条目 ${itemId} 来自公共网络市场，未经官方审核（供应链警示）`,
-        '下载内容为不可信输入，导入前请逐项核对',
+        marketMsg('market.security.warningFromPublicMarket', { itemId }),
+        marketMsg('market.security.warningUntrustedContent'),
     ];
 }
 //# sourceMappingURL=security.js.map

package/lib/market/types.js

@@ -1,3 +1,4 @@
+import { marketMsg } from './messages-market.js';
 /** index.json schema 版本（本版恒 1） */
 export const MARKET_INDEX_SCHEMA_VERSION = 1;
 /** items/<id>/manifest.json schema 版本（本版恒 1） */
@@ -22,7 +23,7 @@ export const SAFE_ITEM_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 /** 校验 itemId 是否合法；不合法抛错（防 items/<id>/ 越界）。 */
 export function assertSafeItemId(id) {
     if (typeof id !== 'string' || !SAFE_ITEM_ID_RE.test(id)) {
-        throw new Error(`非法市场条目 id: ${JSON.stringify(id)}（仅允许字母数字开头，字符限 . _ -）`);
+        throw new Error(marketMsg('market.types.itemIdInvalid', { id: JSON.stringify(id) }));
     }
 }
 //# sourceMappingURL=types.js.map

package/lib/market/url.js

@@ -7,13 +7,14 @@
  * 复用 sync 的 validateRepoUrl（拒绝 userinfo / 空白），叠加 scheme 强制。
  */
 import { validateRepoUrl } from '../sync/sync-config.js';
+import { marketMsg } from './messages-market.js';
 /** 校验市场仓库地址；合法返回 null，非法返回错误消息。仅接受 http(s)，拒绝 git@/ssh/空白/含 userinfo。 */
 export function validateMarketRepoUrl(repoUrl) {
     const err = validateRepoUrl(repoUrl);
     if (err !== null)
         return err;
     if (!/^https?:\/\//i.test(repoUrl.trim())) {
-        return '市场仓库地址仅支持 http(s)（拒绝 git@/ssh 等形态）';
+        return marketMsg('market.url.schemeUnsupported');
     }
     return null;
 }

package/lib/migrations/index.js

@@ -6,6 +6,7 @@
  */
 import { CURRENT_SCHEMA_VERSION, MIN_SUPPORTED_SCHEMA_VERSION, UnsupportedSchemaError } from '../schema/versions.js';
 import { V1_TO_V2 } from './v1-to-v2.js';
+import { migMsg } from './messages-migrations.js';
 /**
  * 迁移注册表：按 from 升序的链式步骤。
  * 当前只有 v1→v2 占位（CURRENT=1 时不会触发，schema v2 发布后生效）。
@@ -15,7 +16,7 @@ export const MIGRATIONS = [V1_TO_V2];
 export function registerMigration(step) {
     const dup = MIGRATIONS.find((s) => s.from === step.from || s.to === step.to);
     if (dup)
-        throw new Error(`迁移步骤冲突: ${step.from}→${step.to} 与 ${dup.from}→${dup.to} 重叠`);
+        throw new Error(migMsg('migrations.stepConflict', { stepFrom: step.from, stepTo: step.to, dupFrom: dup.from, dupTo: dup.to }));
     MIGRATIONS.push(step);
     MIGRATIONS.sort((a, b) => a.from - b.from);
 }
@@ -31,10 +32,10 @@ export function migrateToCurrent(doc, fromVersion, targetVersion = CURRENT_SCHEM
         return { doc, migratedFrom: fromVersion, applied: [] };
     }
     if (fromVersion > targetVersion) {
-        throw new UnsupportedSchemaError(fromVersion, `备份 schema v${fromVersion} 高于当前 v${targetVersion}，需升级本插件`);
+        throw new UnsupportedSchemaError(fromVersion, migMsg('migrations.schemaTooNew', { from: fromVersion, target: targetVersion }));
     }
     if (fromVersion < MIN_SUPPORTED_SCHEMA_VERSION) {
-        throw new UnsupportedSchemaError(fromVersion, `备份 schema v${fromVersion} 低于最低支持 v${MIN_SUPPORTED_SCHEMA_VERSION}`);
+        throw new UnsupportedSchemaError(fromVersion, migMsg('migrations.schemaTooOld', { from: fromVersion, min: MIN_SUPPORTED_SCHEMA_VERSION }));
     }
     let current = doc;
     let version = fromVersion;
@@ -42,10 +43,10 @@ export function migrateToCurrent(doc, fromVersion, targetVersion = CURRENT_SCHEM
     while (version < targetVersion) {
         const step = MIGRATIONS.find((s) => s.from === version && s.to <= targetVersion);
         if (!step) {
-            throw new UnsupportedSchemaError(version, `没有从 schema v${version} 到 v${targetVersion} 的迁移路径`);
+            throw new UnsupportedSchemaError(version, migMsg('migrations.noPath', { from: version, to: targetVersion }));
         }
         if (step.to <= step.from) {
-            throw new Error(`迁移步骤 ${step.from}→${step.to} 未前进（注册表损坏）`);
+            throw new Error(migMsg('migrations.stepNotAdvanced', { from: step.from, to: step.to }));
         }
         current = step.migrate(current);
         applied.push({ from: step.from, to: step.to });

package/lib/migrations/messages-migrations.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 迁移链领域消息目录（zh 源 / en 镜像）。
+ *
+ * 为什么不放在 src/core/messages-core.ts：架构边界（tests/architecture-boundaries.test.ts）
+ * 规定 src/migrations/** 只允许依赖 node 内置 / 自身 / ../schema / ../utils，
+ * **不得 import ../core** —— 迁移链必须保持对 core 零耦合（core 消费它，不能反过来）。
+ * 因此本目录自带一份零依赖的消息解析器：语言源由 core 侧接线（core → migrations 是允许方向，
+ * 见 src/core/messages-core.ts 的 setMigrationLanguageSource），未接线时 = zh
+ * （与迁移链改造前的行为逐字一致）。
+ *
+ * 纪律：
+ *  - zh 值 = 改造前的中文字面量原样（逐字不变，既有测试断言依赖它）；
+ *  - en 值类型 Record<keyof typeof zh, string>（缺键/多键即编译错误），必须纯英文；
+ *  - 动态明细（版本号、from/to）一律以 {param} 插值传入。
+ */
+export declare const zh: {
+    'migrations.stepConflict': string;
+    'migrations.schemaTooNew': string;
+    'migrations.schemaTooOld': string;
+    'migrations.noPath': string;
+    'migrations.stepNotAdvanced': string;
+};
+export declare const en: Record<keyof typeof zh, string>;
+export type MigrationMessageKey = keyof typeof zh;
+export type MigrationMessageParams = Readonly<Record<string, string | number>>;
+/** core 侧接线：让迁移链文案跟随引擎语言（core → migrations 是允许方向）。 */
+export declare function setMigrationLanguageSource(resolve: () => 'zh' | 'en'): void;
+/**
+ * 迁移链的活翻译器：每次调用解析当前语言（默认 zh，绝不抛错），未知键回落键名。
+ * 与 src/core/engine-locale.ts 的 engineMsg 同口径，只是不依赖 core。
+ */
+export declare function migMsg(key: MigrationMessageKey, params?: MigrationMessageParams): string;

package/lib/migrations/messages-migrations.js

@@ -0,0 +1,58 @@
+/**
+ * 迁移链领域消息目录（zh 源 / en 镜像）。
+ *
+ * 为什么不放在 src/core/messages-core.ts：架构边界（tests/architecture-boundaries.test.ts）
+ * 规定 src/migrations/** 只允许依赖 node 内置 / 自身 / ../schema / ../utils，
+ * **不得 import ../core** —— 迁移链必须保持对 core 零耦合（core 消费它，不能反过来）。
+ * 因此本目录自带一份零依赖的消息解析器：语言源由 core 侧接线（core → migrations 是允许方向，
+ * 见 src/core/messages-core.ts 的 setMigrationLanguageSource），未接线时 = zh
+ * （与迁移链改造前的行为逐字一致）。
+ *
+ * 纪律：
+ *  - zh 值 = 改造前的中文字面量原样（逐字不变，既有测试断言依赖它）；
+ *  - en 值类型 Record<keyof typeof zh, string>（缺键/多键即编译错误），必须纯英文；
+ *  - 动态明细（版本号、from/to）一律以 {param} 插值传入。
+ */
+export const zh = {
+    'migrations.stepConflict': '迁移步骤冲突: {stepFrom}→{stepTo} 与 {dupFrom}→{dupTo} 重叠',
+    'migrations.schemaTooNew': '备份 schema v{from} 高于当前 v{target}，需升级本插件',
+    'migrations.schemaTooOld': '备份 schema v{from} 低于最低支持 v{min}',
+    'migrations.noPath': '没有从 schema v{from} 到 v{to} 的迁移路径',
+    'migrations.stepNotAdvanced': '迁移步骤 {from}→{to} 未前进（注册表损坏）',
+};
+export const en = {
+    'migrations.stepConflict': 'Migration step conflict: {stepFrom}→{stepTo} overlaps {dupFrom}→{dupTo}',
+    'migrations.schemaTooNew': 'Backup schema v{from} is newer than the current v{target}; upgrade this plugin',
+    'migrations.schemaTooOld': 'Backup schema v{from} is older than the minimum supported v{min}',
+    'migrations.noPath': 'No migration path from schema v{from} to v{to}',
+    'migrations.stepNotAdvanced': 'Migration step {from}→{to} does not advance (corrupt registry)',
+};
+let languageSource = () => 'zh';
+/** core 侧接线：让迁移链文案跟随引擎语言（core → migrations 是允许方向）。 */
+export function setMigrationLanguageSource(resolve) {
+    languageSource = resolve;
+}
+/** 插值：{param} → 形参值；缺参原样保留（与 engine-locale.ts 的 interpolate 同口径）。 */
+function interpolate(template, params) {
+    if (params === undefined)
+        return template;
+    return template.replace(/\{(\w+)\}/g, (match, key) => {
+        const value = params[key];
+        return value === undefined ? match : String(value);
+    });
+}
+/**
+ * 迁移链的活翻译器：每次调用解析当前语言（默认 zh，绝不抛错），未知键回落键名。
+ * 与 src/core/engine-locale.ts 的 engineMsg 同口径，只是不依赖 core。
+ */
+export function migMsg(key, params) {
+    let lang = 'zh';
+    try {
+        lang = languageSource() === 'en' ? 'en' : 'zh';
+    }
+    catch {
+        lang = 'zh';
+    }
+    return interpolate((lang === 'en' ? en : zh)[key], params);
+}
+//# sourceMappingURL=messages-migrations.js.map