@logictan/dsh-config-manager 0.1.61 → 0.1.62

package/lib/ui/types.d.ts

@@ -118,25 +118,12 @@ export interface RollbackView {
 export interface ImportPort {
     analyzeImport(zipPath: string): Promise<ImportAnalysis>;
     createImportPlan(zipPath: string, decisions: ImportDecisions): Promise<ImportPlan>;
-    /**
-     * 解锁整体加密备份（只读，零写入）：用备份密码解密上传的加密容器，得到明文 ZIP
-     * 写入受控临时目录并返回新的 zipPath，供 analyze/plan/execute 引用。
-     * 顺带返回解密覆盖的凭据 ref 名（非值）——导出时容器密码与内部 secrets.enc
-     * 密码同源，解锁即完成凭据解密验证，无需第二次密码校验。
-     * 密码仅内存，绝不落盘/落日志；解密后的明文 ZIP 亦为临时文件，导入结束后清理。
-     */
-    decryptArchive(zipPath: string, password: string): Promise<{
-        zipPath: string;
-        refs: string[];
-    }>;
     executeImportPlan(zipPath: string, plan: ImportPlan, opts: {
         /** 用户确认（安全阀，非 true 拒绝执行） */
         confirm: boolean;
         secretInputs?: Record<string, string>;
         /** 显式回滚策略：true=任一项失败整体回滚（场景 E）；false=单项失败继续（§34.17） */
         rollbackOnError: boolean;
-        /** 加密备份的解密密码（仅内存；core 拒绝加密备份无密码执行） */
-        decryptPassword?: string;
     }): Promise<ImportResult>;
 }
 /** 选项构造辅助：从 PlanItem 提取稳定决策键（与 core analyzer.applyItemResolution 的 id 语义一致） */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logictan/dsh-config-manager",
-  "version": "0.1.61",
+  "version": "0.1.62",
   "license": "MIT",
   "description": "Sync your DeepSeek Harness (DSH) configuration between machines over a private git or WebDAV channel: settings, plugins, MCP servers, skills, agent presets, workspaces and provider credentials. DSH 配置远程同步插件（私有通道，明文自用）。",
   "keywords": [

package/src/adapters/credentials.ts

@@ -5,7 +5,7 @@
  *
  * 安全不变量：永不导出值（hasValue 恒 false）；导入生成 MissingSecret 清单，
  * 用户补录值经 ctx.secretInputs / decryptedCredentials（仅内存）→ credentials.set()。
- * .credentials.yaml 文件字节交由 m4 加密层处理，本 adapter 不触碰。
+ * .credentials.yaml 文件字节由 Exporter 的文件级 vault 处理，本 adapter 不触碰。
  */
 import type { CredentialStatus, CredentialsSection } from '../schema/types.ts';
 import { msgOf, zhMsg } from '../core/messages.ts';

package/src/client/config-manager.module.css

@@ -2284,7 +2284,7 @@ button.statCard:focus-visible {
   padding: 1px 0;
 }
 
-/* 选项行（加密/导出密钥复选内联） */
+/* 选项行（导出密钥复选内联） */
 .optionsRow {
   display: flex;
   align-items: center;

package/src/client/run-store.test.ts

@@ -2,7 +2,7 @@
  * run-store 单测：模块级单例 store + sessionStorage 恢复（同步面板专属）。
  *
  * 覆盖：
- *  - 敏感字段（token/webdavPassword/encryptPassword 等）绝不写入 sessionStorage（白名单剔除）；
+ *  - 敏感字段（token/webdavPassword 等）绝不写入 sessionStorage（白名单剔除）；
  *  - 内存瞬态（busy/savingConfig）不写入 sessionStorage，刷新后复位；
  *  - 非敏感状态序列化/反序列化往返（新实例 + 同存储 = 模拟刷新）；
  *  - 损坏/版本不符数据回退默认并清除脏键；

package/src/client/sync/SyncSettingsView.tsx

@@ -8,7 +8,7 @@
  *   dialogMask + dialogCard dialogWide + dialogHeaderRow + dialogClose +
  *   dialogBodyScroll，零新增样式）；
  * - **通道配置弹窗**：通道子 tab（GitHub（git）/ WebDAV）切换，两个通道的
- *   配置表单、自动同步、同步模式、是否加密、远端快照**各自独立**；关闭弹窗
+ *   配置表单、自动同步、同步模式、远端快照**各自独立**；关闭弹窗
  *   = 放弃本次操作（GitHub 登录流程进行中则一并取消，§8.12 约定）；
  * - GitHub 子 tab：repoUrl（必填）+ 认证 token（可选，写入 DSH credentials 的提示）
  *   + **GitHub OAuth device flow 登录**（登录块跟随 git 通道配置放在弹窗内：
@@ -24,7 +24,7 @@
  * 全部渲染模型来自 ./sync-view.ts 纯函数（node 单测覆盖），组件只做装配；
  * 状态组件内自持（useState），同时经 toSyncStoreSlice() 镜像进模块级 runStore：
  * 模块级单例保证「切 tab 不丢」，sessionStorage 白名单保证「刷新恢复」；
- * token/webdav 密码/加密与解密密码仅内存（state），成功后清空（已写入 DSH
+ * token/webdav 密码仅内存（state），成功后清空（已写入 DSH
  * credentials），持久化白名单硬性剔除（含 byChannel 内密码类字段），刷新后
  * 清空、需要时重新输入。
  */
@@ -89,7 +89,7 @@ interface SyncUiState {
   webdavUsername: string
   /** 仅内存：成功后清空（已写入 DSH credentials），绝不持久化/回显 */
   webdavPassword: string
-  /** git/webdav 各自独立的设置状态（自动同步 / 同步模式 / 加密 / 快照） */
+  /** git/webdav 各自独立的设置状态（自动同步 / 同步模式 / 快照） */
   byChannel: {
     git: ChannelSyncState
     webdav: ChannelSyncState
@@ -174,7 +174,7 @@ const initial: SyncUiState = {
 
 /**
  * 从 runStore 恢复上次的同步 UI 状态（切 tab 回 / 刷新后挂载）。
- * 敏感字段（token/webdav 密码/加密与解密密码）只在内存切片里保留：切 tab 保留；
+ * 敏感字段（token/webdav 密码）只在内存切片里保留：切 tab 保留；
  * 刷新后已被持久化白名单清空（applyPersisted 强制归零）→ 需要时重新输入。
  * busy/savingConfig 为瞬态：切 tab 由模块级单例保留（切回仍显示进行中）；
  * 刷新后白名单剔除 → 回复空闲。
@@ -240,7 +240,7 @@ export function SyncSettingsView({ api, t }: SyncSettingsViewProps) {
   })
   /** 更新当前激活通道的 byChannel 状态。 */
   const patchChannel = (p: Partial<ChannelSyncState>): void => patchChannelState(state.channel, p)
-  /** 当前激活通道的设置状态（自动同步/模式/加密/快照）。 */
+  /** 当前激活通道的设置状态（自动同步/模式/快照）。 */
   const chState: ChannelSyncState = state.byChannel[state.channel]
   /** GitHub 流程态（不进 store 切片；commit 的镜像写幂等无害）。 */
   const patchGithub = (p: Partial<GithubUiState>): void => commit({

package/src/client/sync/sync-locales.ts

@@ -331,7 +331,6 @@ export const en: Record<keyof typeof zh, string> = {
   'mode.defaultCount': 'Will sync {n} recommended section(s)',
   'mode.sectionRecommended': 'Recommended',
   'mode.persistHint': 'The mode and section selection are saved locally: both auto sync and manual push use this configuration (persists across restarts).',
-  // Encryption & secret export (manual push only; auto sync always pushes plain snapshots and skips encrypted ones)
   'autosync.title': 'Auto Sync',
   'autosync.description': 'When enabled, DSH keeps config in sync in the background: uploads locally-changed config automatically, pulls and overwrites only when it detects a new remote snapshot; the timer is just a fallback poll and no-ops when nothing changed. Local writes happen only when there are no conflicts or manual-decision items.',
   'autosync.enable': 'Enable auto sync',

package/src/core/analyzer.ts

@@ -526,8 +526,9 @@ export class Analyzer {
       throw new ImportNotConfirmedError(this.msg);
     }
 
-    // 10b. 加密不变量：加密备份必须已成功解密（decryptedCredentials 由宿主用备份密码
-    // 解开 security/secrets.enc 后注入）。未解密（undefined）一律拒绝执行——
+    // 10b. 旧版加密备份的兼容不变量：本插件已无加密层，但历史产物仍可能带
+    // manifest.security.encrypted=true。这类备份的凭据必须由宿主解密后注入
+    // （decryptedCredentials）；未注入（undefined）一律拒绝执行——
     // 不允许把加密凭据静默降级为「缺凭据照常导入」，否则加密备份与普通备份无区别。
     if (bundle.manifest.security.encrypted && opts.decryptedCredentials === undefined) {
       throw new Error(this.msg('import.encryptedPasswordRequired'));
@@ -725,8 +726,8 @@ export class Analyzer {
     // M1：导入成功 → 快照标记 done（元数据写失败只告警，不改变导入结论）
     await this.markSnapshotStatus(snapshot.id, 'done');
 
-    // F1 vault 回填：导出时敏感文件（.credentials.yaml 等）明文未进备份（includeSecrets=false
-    // 时镜像到 <dataDir>/vault），导入成功后从本机 vault 回填 $DSH_HOME；vault 缺失
+    // F1 vault 回填：includeSecrets=false 的导出会把敏感文件（.credentials.yaml 等）镜像到
+    // <dataDir>/vault 而不进备份，导入成功后从本机 vault 回填 $DSH_HOME；vault 缺失
     // （跨机恢复 / 从未镜像过）记入警告提示用户重填。尽力而为：失败仅警告，不影响导入结论。
     try {
       const vaultDataDir = path.join(this.ctx.homeDir, 'dsh-config-manager');

package/src/core/exporter.ts

@@ -3,11 +3,9 @@
  *   adapter 收集各分区 → Secret 过滤 → manifest → checksum → ZIP。
  *
  * 安全不变量：
- *  - Secret 值默认永不进入导出数据（结构化分区逐一过 SecretScanner）；
- *  - includeSecrets=true 必须注入 EncryptionProvider（m4 实现），否则拒绝导出；
- *  - 注入 EncryptionProvider 时备份标记为加密（encrypted=true）：includeSecrets=false
- *    时 secrets.enc 加密空内容占位，备份仍需要密码导入，但不含任何凭据值；
- *  - 加密密码/秘密值绝不写入 manifest 与日志。
+ *  - Secret 值默认永不进入导出数据（结构化分区逐一过 SecretScanner 剥离值）；
+ *  - 备份恒为明文（encrypted=false / encryption=null）：本插件不再有加密层；
+ *  - 秘密值绝不写入 manifest 与日志。
  */
 import fs from 'node:fs/promises';
 import path from 'node:path';
@@ -21,7 +19,7 @@ import { msgOf } from './messages.ts';
 import type { MsgFunc } from './messages.ts';
 import type { Manifest, SectionId } from '../schema/types.ts';
 import type {
-  ConfigAdapter, EncryptionProvider, ExportOptions, ExportReport,
+  ConfigAdapter, ExportOptions, ExportReport,
   ExportSection, HostContext, SecretScanner, SensitiveHit,
 } from './types.ts';
 
@@ -39,8 +37,6 @@ export interface ExporterOptions {
   adapters: ConfigAdapter[];
   /** Secret 扫描器；缺省用字段名黑名单剥离（m4 可注入强化版） */
   scanner?: SecretScanner;
-  /** 加密提供者（m4 用 node:crypto 实现）；includeSecrets 时必填；提供时备份标记 encrypted=true */
-  encryption?: EncryptionProvider | null;
   /** 插件自身版本（manifest.exporter.version） */
   exporterVersion?: string;
   now?: () => Date;
@@ -176,7 +172,6 @@ export class Exporter {
   private readonly ctx: HostContext;
   private readonly adapters: ConfigAdapter[];
   private readonly scanner: SecretScanner;
-  private readonly encryption: EncryptionProvider | null;
   private readonly exporterVersion: string;
   private readonly now: () => Date;
   private readonly msg: MsgFunc;
@@ -187,7 +182,6 @@ export class Exporter {
     this.ctx = opts.ctx;
     this.adapters = opts.adapters;
     this.scanner = opts.scanner ?? defaultSecretScanner();
-    this.encryption = opts.encryption ?? null;
     this.exporterVersion = opts.exporterVersion ?? '0.1.0';
     this.now = opts.now ?? (() => new Date());
     this.msg = opts.msg ?? msgOf(opts.ctx);
@@ -201,9 +195,6 @@ export class Exporter {
    */
   async export(options: ExportOptions): Promise<{ zipPath: string; manifest: Manifest; report: ExportReport }> {
     const { includeSecrets, only } = options;
-    if (includeSecrets && !this.encryption) {
-      throw new Error(this.msg('export.encryptionRequired'));
-    }
 
     // 1. 选定分区（only 过滤 + 默认包含）
     const selected = this.adapters
@@ -214,6 +205,8 @@ export class Exporter {
     const sections: ExportSection[] = [];
     const warnings: string[] = [];
     const redactedHits: SensitiveHit[] = [];
+    /** 文件类分区实扫到的命中数：只有它能让 containsSecrets 为真（结构化分区已被剥离） */
+    let fileSectionSecretHits = 0;
     const included: ExportReport['included'] = [];
     const excluded: SectionId[] = this.adapters.filter((a) => !selected.includes(a.id)).map((a) => a.id);
 
@@ -249,6 +242,7 @@ export class Exporter {
         if (fileHits.length > 0) {
           // redactedHits 是**报告统计**通道（非告警通道）：仍计入全量命中（含同一文件的多行/多形态命中）。
           redactedHits.push(...fileHits);
+          fileSectionSecretHits += fileHits.length;
           // 告警按**文件**去重（G-09/H1）：同一路径只告警一次。
           // 修复前按 hit 计数，同一行同时命中「字段名」与「值形状」会产出两条同路径告警，
           // 使少数文件就吃满上限，导致含真实明文凭据的其它文件被静默淹没（实测 redactedHits=8 而 5 条告警全属一个文件）。
@@ -278,12 +272,13 @@ export class Exporter {
       warnings.push(...section.warnings);
     }
 
-    // 4. 组装 ZIP 条目（JSON 分区 + 文件类分区 + secrets.enc + checksums + manifest）
+    // 4. 组装 ZIP 条目（JSON 分区 + 文件类分区 + checksums + manifest）
     const entries: { name: string; data: Uint8Array }[] = [];
     const sectionFlags = buildSectionFlags(sections);
-    let containsSecrets = false;
-    let encrypted = false;
-    let encryption: Manifest['security']['encryption'] = null;
+    // 备份恒为明文：本插件不再有加密层。containsSecrets 只认「文件类分区实扫到的命中」——
+    // 结构化分区的敏感值已被 scanner 剥离，不构成「含秘密」；文件类分区只报告不改写，
+    // 命中即代表归档里确有明文，必须如实标注。
+    const containsSecrets = fileSectionSecretHits > 0;
 
     for (const section of sections) {
       if (isFileSection(section.sectionId)) {
@@ -302,33 +297,8 @@ export class Exporter {
       });
     }
 
-    // secrets.enc：有加密提供者即生成。includeSecrets=true 时加密真实的凭据原文；
-    // 只勾选加密（不导出密钥）时加密空内容占位，备份仍标记 encrypted（导入需密码），
-    // 但绝不把凭据值放进去（containsSecrets 保持 false；安全不变量不破）。
-    if (this.encryption) {
-      const credentialsFile = path.join(this.ctx.homeDir, '.credentials.yaml');
-      let plaintext: string;
-      if (includeSecrets) {
-        try {
-          const raw = await this.ctx.fs.readFile(credentialsFile);
-          plaintext = Buffer.from(raw).toString('utf8');
-        } catch (err) {
-          warnings.push(this.msg('export.credentialsReadFailed', { reason: err instanceof Error ? err.message : String(err) }));
-          plaintext = '';
-        }
-      } else {
-        plaintext = '';
-      }
-      const result = await this.encryption.encrypt(plaintext);
-      entries.push({ name: 'security/secrets.enc', data: result.blob });
-      encryption = result.info;
-      containsSecrets = includeSecrets && plaintext !== '';
-      encrypted = true;
-    }
-
     // 4b. 文件级 vault（includeSecrets=false：敏感文件明文不进归档 → 镜像到本机 vault）。
-    //     尽力而为：任何失败仅记警告，不中断导出。includeSecrets=true 时秘密已加密进归档，
-    //     无需镜像（vault 只服务于「明文不进备份」的本机留存场景）。
+    //     尽力而为：任何失败仅记警告，不中断导出。
     let vaultRefreshed = 0;
     if (!includeSecrets) {
       try {
@@ -357,8 +327,8 @@ export class Exporter {
       arch: this.ctx.arch,
       sections: sectionFlags,
       containsSecrets,
-      encrypted,
-      encryption,
+      encrypted: false,
+      encryption: null,
       exportedAt: this.now().toISOString(),
     });
     entries.push({ name: MANIFEST_FILE, data: Buffer.from(stringifyJsonSafe(manifest, { space: 2 }), 'utf8') });
@@ -375,7 +345,6 @@ export class Exporter {
       sections: Object.keys(sectionFlags).filter((k) => sectionFlags[k as SectionId]),
       redactedFields: redactedHits.length,
       containsSecrets,
-      encrypted,
       vaultRefreshed,
     });
 
@@ -385,7 +354,6 @@ export class Exporter {
       security: {
         secretsExcluded: !includeSecrets,
         containsSecrets,
-        encrypted,
         redactedHits: redactedHits.length,
         vaultRefreshed,
       },

package/src/core/importer.ts

@@ -36,7 +36,7 @@ export interface ExecuteOptions {
   confirm: boolean;
   /** 用户补录的秘密值（仅内存） */
   secretInputs?: Record<string, string>;
-  /** 加密备份解密结果（仅内存；解密必须经 m4 encryption provider） */
+  /** 旧版加密备份的解密结果（仅内存；宿主解密后注入，本插件不再产生加密备份） */
   decryptedCredentials?: Map<string, string>;
   /** 任一项失败立即整体回滚（默认 false：单项失败如实记录并继续其余项） */
   rollbackOnError?: boolean;

package/src/core/index.ts

@@ -47,7 +47,7 @@ export type {
   ExportOptions, ExportSection, ValidationResult, HostContext,
   SettingsFacade, CredentialsFacade, PluginsFacade, WorkspaceFacade,
   PatchFileFacade, FileSystemFacade, NamespaceInfo, PluginInfo,
-  ConfigAdapter, Portability, SecretScanner, SensitiveHit, EncryptionProvider,
+  ConfigAdapter, Portability, SecretScanner, SensitiveHit,
   PlanItem, PlanItemKind, ItemResolution, GlobalConflictStrategy,
   ImportAnalysis, ImportDecisions, ImportPlan, ImportResult, ExecutedItem,
   ImportContext, SnapshotTarget, SnapshotEntry, Snapshot, SnapshotStore,

package/src/core/messages.ts

@@ -18,9 +18,7 @@ export type { MsgFunc, MsgParams } from './msg-types.ts';
 
 export const zh = {
   // ---------- 导出 ----------
-  'export.encryptionRequired': '导出包含秘密需要注入 EncryptionProvider（m4 实现），拒绝明文导出秘密',
   'export.sectionFailed': '分区 {adapter} 导出失败: {reason}',
-  'export.credentialsReadFailed': '读取凭据文件失败，跳过秘密导出: {reason}',
   'export.vaultRefreshed': '凭据明文未进入备份，已镜像到本机 vault（{count} 个文件，恢复时可回填）',
   'export.vaultRefreshSkipped': 'vault 镜像跳过 {rel}: {reason}',
   'export.vaultRefreshFailed': 'vault 镜像刷新失败（不影响导出）: {reason}',
@@ -53,9 +51,7 @@ export const zh = {
   'import.secretMissingDesc': '凭据 {ref} 需要补录',
   'import.secretNotProvided': '凭据未提供，需补录',
   'import.notConfirmed': '导入未确认：必须显式 confirm 后才允许修改任何数据',
-  'import.encryptedPasswordRequired': '该备份已加密，必须提供解密密码才能导入（拒绝无密码导入）',
-  'import.encryptedPasswordWrong': '解密密码错误，请重试',
-  'import.notEncryptedContainer': '该文件不是加密备份容器，无法解锁',
+  'import.encryptedPasswordRequired': '该备份含上游历史加密凭据（security.encrypted=true），本插件无解密能力：须由宿主解密后注入凭据（decryptedCredentials）才能导入',
   'import.userSkipped': '用户跳过（导入中点击「跳过当前插件」）',
   'import.userSkippedDetail': '插件 {name} 已由用户跳过，未安装',
   'import.vaultRestored': '凭据文件 {rel} 已从本机 vault 回填',
@@ -327,9 +323,7 @@ export const zh = {
 
 export const en: Record<keyof typeof zh, string> = {
   // ---------- export ----------
-  'export.encryptionRequired': 'Encrypted export requires an EncryptionProvider (m4); refusing to export secrets in plaintext',
   'export.sectionFailed': 'Section {adapter} export failed: {reason}',
-  'export.credentialsReadFailed': 'Failed to read the credentials file; secrets export skipped: {reason}',
   'export.vaultRefreshed': 'Credential plaintext did not enter the backup; mirrored to the local vault ({count} file(s), available for restore backfill)',
   'export.vaultRefreshSkipped': 'Vault mirror skipped {rel}: {reason}',
   'export.vaultRefreshFailed': 'Vault mirror refresh failed (export unaffected): {reason}',
@@ -362,9 +356,7 @@ export const en: Record<keyof typeof zh, string> = {
   'import.secretMissingDesc': 'Credential {ref} needs to be re-entered',
   'import.secretNotProvided': 'Credential not provided; requires re-entry',
   'import.notConfirmed': 'Import not confirmed: explicit confirm is required before any data is modified',
-  'import.encryptedPasswordRequired': 'This backup is encrypted; the decryption password is required to import it (refusing password-less import)',
-  'import.encryptedPasswordWrong': 'Wrong decryption password, please try again',
-  'import.notEncryptedContainer': 'This file is not an encrypted backup container and cannot be unlocked',
+  'import.encryptedPasswordRequired': 'This backup carries upstream-encrypted credentials (security.encrypted=true) and this plugin cannot decrypt them: a host must decrypt and inject them (decryptedCredentials) before import',
   'import.userSkipped': 'Skipped by user (clicked "Skip current plugin" during import)',
   'import.userSkippedDetail': 'Plugin {name} was skipped by the user and not installed',
   'import.vaultRestored': 'Credential file {rel} backfilled from the local vault',

package/src/core/smoke.test.ts

@@ -827,15 +827,15 @@ test('兼容性评分规则', () => {
   assert.equal(computeCompatibility({ sourceDsh: '0.1.0-rc.6', targetDsh: '0.1.0-rc.6', sourcePlatform: 'win32', targetPlatform: 'win32', schemaVersion: 999, missingSections: [] }), 'unsupported');
 });
 
-test('包含秘密导出：无加密提供者时拒绝（绝不明文泄密）', async () => {
+test('包含秘密导出：本插件无加密层，明文导出照常进行且备份恒标记未加密', async () => {
   const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-cm-sec-'));
   try {
     const src = makeContext('win32', 'C:\\Users\\alice');
     const exporter = new Exporter({ ctx: src, adapters: makeAdapters(), now: () => new Date() });
-    await assert.rejects(
-      () => exporter.export({ includeSecrets: true, outPath: path.join(tmp, 'x.zip') }),
-      /EncryptionProvider/,
-    );
+    const { manifest, report } = await exporter.export({ includeSecrets: true, outPath: path.join(tmp, 'x.zip') });
+    assert.equal(manifest.security.encrypted, false, '备份恒为明文');
+    assert.equal(manifest.security.encryption, null, '不存在加密参数');
+    assert.equal(report.security.secretsExcluded, false, 'includeSecrets=true 时不走 vault 留存路径');
   } finally {
     await fs.rm(tmp, { recursive: true, force: true });
   }

package/src/core/types.ts

@@ -5,7 +5,7 @@
  * HostContext 是 m3 定义、m5 实现的 DSH Service 门面（研究报告 §3.2 的叶子方法最小集），
  * 测试用内存 mock 即可驱动完整导出→导入往返。
  */
-import type { EncryptionInfo, Manifest, SectionId, WorkspaceRecord } from '../schema/types.ts';
+import type { Manifest, SectionId, WorkspaceRecord } from '../schema/types.ts';
 import type { TombstoneKind } from '../schema/tombstones.ts';
 import type { MutationLockPort } from '../utils/env-lock.ts';
 import type { RecursiveListing } from '../utils/recursive-walk.ts';
@@ -16,7 +16,11 @@ import type { MsgFunc } from './messages.ts';
 /* ---------------- 导出选项与分区产出 ---------------- */
 
 export interface ExportOptions {
-  /** 是否包含真实秘密（必须配合 encryption 提供者；缺省 false = 只导状态） */
+  /**
+   * 是否把真实秘密写入备份。本插件不再有加密层（备份恒为明文），结构化分区的秘密值
+   * 始终由 SecretScanner 剥离，故本开关当前的实际作用只剩「是否刷新本机 vault 镜像」：
+   * false → 导出后把敏感文件镜像到本机 vault（明文不进归档）。
+   */
   includeSecrets: boolean;
   /** 仅导出指定分区（缺省 = 全部默认包含分区） */
   only?: SectionId[];
@@ -235,7 +239,7 @@ export interface ImportAnalysis {
   pathIssues: PathIssue[];
   secretCount: number;
   dependencyIssues: { item: string; dependency: string }[];
-  /** 备份是否加密（manifest.security.encrypted）：加密备份的凭据必须用解密密码恢复 */
+  /** 旧版加密备份标记（manifest.security.encrypted）：本插件不再产生，仅历史产物为 true */
   encrypted: boolean;
 }
 
@@ -298,6 +302,7 @@ export interface ImportContext {
   resolutions: Record<string, ItemResolution>;
   /** 用户补录的秘密值（仅内存，永不落盘/日志） */
   secretInputs: Record<string, string>;
+  /** 旧版加密备份的解密结果（仅内存；宿主解密后注入） */
   decryptedCredentials?: Map<string, string>;
   log: Logger;
   /** 消息翻译器（analyzer 注入；适配器用它生成计划项描述/校验/结果消息） */
@@ -466,7 +471,6 @@ export interface ExportReport {
   security: {
     secretsExcluded: boolean;
     containsSecrets: boolean;
-    encrypted: boolean;
     redactedHits: number;
     /** 本次导出镜像到本机 vault 的敏感文件数（文件级 vault；0 或缺失 = 未镜像） */
     vaultRefreshed?: number;
@@ -504,14 +508,6 @@ export interface ConfigAdapter<TSection = unknown> {
   rollback?(entries: SnapshotEntry[], ctx: HostContext): Promise<void>;
 }
 
-/* ---------------- 加密提供者（m4 用 node:crypto 实现） ---------------- */
-
-export interface EncryptionProvider {
-  encrypt(plaintext: string): Promise<{ blob: Uint8Array; info: EncryptionInfo }>;
-  /** authTag 校验失败必须抛错 */
-  decrypt(blob: Uint8Array, info: EncryptionInfo, password: string): Promise<string>;
-}
-
 /* ---------------- 错误类型 ---------------- */
 
 /** 导入被确认前拒绝执行（安全阀） */

package/src/index.ts

@@ -20,8 +20,8 @@
  *    (isLoopbackRequest); LAN-exposed deployments never serve these endpoints;
  *  - uploads/exported ZIPs are staged under $DSH_HOME/dsh-config-manager/{tmp,exports}
  *    and every `path`/`zipPath` reference is confined to those roots;
- *  - the encryption password is in-memory only: used to derive the AES-256-GCM
- *    key for secrets.enc, never written to any file, manifest, or log;
+ *  - there is no encryption layer: every backup is plaintext, and secret values are
+ *    stripped by the secret scanner before they reach any file, manifest, or log;
  *  - the import execute endpoint refuses to run without `confirm: true`
  *    (core ImportNotConfirmedError safety valve).
  *
@@ -95,7 +95,6 @@ import { ImportNotConfirmedError, ImportUserSkippedError } from './core/types.ts
 import { createAdapters } from './adapters/index.ts'
 import { HOME_PATCH_FILE, PROFILE_PATCH_FILE } from './core/patch-layers.ts'
 import { createLocalPluginPackHook } from './core/local-plugin-host.ts'
-import { createEncryptionProvider, decryptCredentials, decryptArchive, SecurityError, encryptArchive, isArchiveBlob, verifyEncryptedBlob } from './security/index.ts'
 import { createHardenedZipParser } from './security/zip-security.ts'
 import { atomicCopyFile, atomicWriteFile } from './utils/atomic-write.ts'
 import { EnvironmentLockManager, runWithMutationLock, EnvironmentLockUnavailableError, type MutationLockContext } from './utils/env-lock.ts'
@@ -140,11 +139,10 @@ import { createConfiguredSecretScanner } from './security/secret-scanner.ts'
 import type { ConfiguredSecretPatterns } from './security/secret-scanner.ts'
 import type { SecretScanner } from './core/types.ts'
 import { sha256Hex } from './utils/hashing.ts'
-import { MANIFEST_FILE, parseManifest } from './schema/manifest.ts'
 import { isFileSection, SECTION_IDS } from './schema/config.ts'
 import { stringifyJsonSafe } from './utils/json.ts'
-import type { Manifest, SectionId, WorkspaceRecord } from './schema/types.ts'
-import { parseZip, zipToBuffer } from './utils/zip.ts'
+import type { SectionId, WorkspaceRecord } from './schema/types.ts'
+import { zipToBuffer } from './utils/zip.ts'
 import { isSameOrChild, normalizePath } from './utils/paths.ts'
 import { createLogger, type Logger } from './utils/logger.ts'
 
@@ -157,7 +155,7 @@ export const name = 'config-manager'
 export const inject = ['settings', 'credentials']
 
 /** Plugin version, kept in sync with package.json ("version"). */
-const PLUGIN_VERSION = '0.1.61'
+const PLUGIN_VERSION = '0.1.62'
 
 /** Plugin own package name — excluded from its own exported plugins list. */
 const PLUGIN_NAME = 'dsh-config-manager'
@@ -919,48 +917,6 @@ async function withTimeout<T>(promise: Promise<T>, ms: number, message: string):
   }
 }
 
-/** Decrypt an encrypted backup's credentials (in-memory only; undefined when not applicable). */
-async function tryDecryptCredentials(
-  zipPath: string,
-  password: string | undefined,
-): Promise<Map<string, string> | undefined> {
-  if (password === undefined || password === '') return undefined
-  const raw = await fs.readFile(zipPath)
-  const archive = parseZip(raw)
-  if (!archive.has(MANIFEST_FILE)) return undefined
-  let manifest: Manifest
-  try {
-    manifest = parseManifest(archive.readEntryText(MANIFEST_FILE))
-  } catch {
-    return undefined
-  }
-  if (!manifest.security.encrypted || manifest.security.encryption === null) return undefined
-  if (!archive.has('security/secrets.enc')) return undefined
-  const blob = archive.readEntry('security/secrets.enc')
-  const plaintext = await decryptCredentials(blob, manifest.security.encryption, password)
-  let parsed: unknown
-  try {
-    parsed = yaml.load(plaintext)
-  } catch {
-    return undefined
-  }
-  const map = new Map<string, string>()
-  if (parsed !== null && typeof parsed === 'object') {
-    for (const [k, v] of Object.entries(parsed as Record<string, unknown>)) {
-      if (typeof v === 'string' && v !== '') map.set(k, v)
-    }
-  }
-  return map
-}
-
-/** 解密错误 → 用户可读文本：BAD_PASSWORD 只报「密码错误」（不泄内部细节），其余原文 */
-function decryptErrorText(error: unknown, msg: MsgFunc): string {
-  if (error instanceof SecurityError && error.code === 'BAD_PASSWORD') {
-    return msg('import.encryptedPasswordWrong')
-  }
-  return error instanceof Error ? error.message : String(error)
-}
-
 interface RoutesDeps {
   host: ConfigManagerHostContext
   adapters: ConfigAdapter[]
@@ -1840,13 +1796,6 @@ function makeRoutes(deps: RoutesDeps): { routes: WebRoute[]; scheduler: AutoSync
     // 零写入；loopback fence 必备。
     // ------------------------------------------------------------ download
     // -------------------------------------------------------------- upload
-    // ------------------------------------------------------ decrypt-archive
-    // 整体加密备份容器的解锁（只读，零写入到任何配置）：用备份密码解密上传的加密容器，
-    // 得到明文 ZIP 写入受控临时目录并返回新 zipPath，供 analyze/plan/execute 引用。
-    // 导出时容器密码与内部 secrets.enc 密码同源（同一 password 派生两层加密），
-    // 因此顺带在明文 ZIP 上解出内部凭据覆盖清单（refs，非值）一并返回——
-    // 导入全程只需输入这一次密码，无需第二个密码校验页面。
-    // 密码仅内存随请求体传入，绝不落盘/落日志；解出的明文 ZIP 亦为临时文件，导入结束后清理。
     // ------------------------------------------------------------- analyze
     // ---------------------------------------------------------------- plan
     // ------------------------------------------------------------ progress

package/src/security/index.ts

@@ -1,16 +1,14 @@
 /**
  * 安全模块公共出口（m4-security）：
- *  secret-scanner / encryption / integrity / zip-security / redaction。
+ *  secret-scanner / integrity / zip-security / redaction。
  *
  * 与 core 的注入点对齐：
  *  - `createSecretScanner()`        → ExporterOptions.scanner（SecretScanner 契约）
- *  - `createEncryptionProvider(pw)` → ExporterOptions.encryption（EncryptionProvider 契约）
  *  - `createHardenedZipParser()`    → ImporterOptions.parseZipOverride（(buf, limits?) => ZipArchive）
  *  - `safeExtractHardened()`        → m5 导入文件类分区落盘通道
  *  - `verifyChecksumsJson()`        → 完整性校验通道（core analyzer 已有内置校验，本模块供独立调用）
  */
 export * from './secret-scanner.ts';
-export * from './encryption.ts';
 export * from './integrity.ts';
 export * from './zip-security.ts';
 export * from './redaction.ts';