dsh-model-groups 0.3.4 → 0.3.5

package/src/maintenance-state.js

@@ -0,0 +1,171 @@
+export const MAINTENANCE_CONFIRMATION = 'CONFIRM PATCH OPERATION';
+export const MAINTENANCE_ENDPOINT = '/dsh-model-groups/maintenance';
+const MAINTENANCE_KEYS = ['dsh:model-groups:v1', 'dsh:model-groups:mode'];
+const ACTION_CAPABILITIES = { apply: 'canApply', 'restore-only': 'canRestoreOnly', 'restore-and-uninstall': 'canRestore' };
+
+// Never project arbitrary server messages, patch paths, or tokens into the DOM.
+export function maintenanceSnapshot(value) {
+  const phases = ['idle', 'applied', 'restored', 'removing', 'removed', 'failed'];
+  if (!value || !phases.includes(value.phase) || typeof value.restartRequired !== 'boolean'
+    || !Object.values(ACTION_CAPABILITIES).every(key => typeof value[key] === 'boolean')
+    || !(value.token == null || (typeof value.token === 'string' && value.token.length > 0))
+    || (Object.values(ACTION_CAPABILITIES).some(key => value[key]) && !(typeof value.token === 'string' && value.token.length > 0))
+    || !Array.isArray(value.patches) || !Array.isArray(value.blockers)
+    || !(value.warnings == null || (Array.isArray(value.warnings) && value.warnings.every(warning => warning && typeof warning.code === 'string'
+      && (warning.count == null || (Number.isSafeInteger(warning.count) && warning.count > 0)))))
+    || !value.patches.every(patch => patch && ['patched', 'pristine', 'conflict'].includes(patch.state)
+      && (patch.updateAvailable == null || typeof patch.updateAvailable === 'boolean'))
+    || !value.blockers.every(blocker => blocker && typeof blocker.code === 'string' && typeof blocker.message === 'string'
+      && (blocker.count == null || (Number.isSafeInteger(blocker.count) && blocker.count > 0)))) {
+    throw new Error('Invalid maintenance snapshot');
+  }
+  return { phase: value.phase, restartRequired: value.restartRequired, canApply: value.canApply,
+    canRestoreOnly: value.canRestoreOnly, canRestore: value.canRestore,
+    token: value.token ?? null, patches: value.patches.map(patch => ({ state: patch.state, updateAvailable: patch.updateAvailable === true })),
+    blockers: value.blockers.map(blocker => ({ code: blocker.code, count: blocker.count ?? null })),
+    warnings: (value.warnings ?? []).map(warning => ({ code: warning.code, count: warning.count ?? null })) };
+}
+export function maintenanceCanAction(snapshot, action) {
+  const capability = Object.hasOwn(ACTION_CAPABILITIES, action) ? ACTION_CAPABILITIES[action] : null;
+  return !!capability && !!snapshot && ['idle', 'applied', 'restored', 'failed'].includes(snapshot.phase) && snapshot[capability]
+    && typeof snapshot.token === 'string' && snapshot.token.length > 0
+    && !snapshot.patches.some(patch => patch.state === 'conflict');
+}
+export function maintenanceCanRestore(snapshot) { return maintenanceCanAction(snapshot, 'restore-and-uninstall'); }
+export function maintenanceBlockerText(blocker) {
+  const labels = {
+    active_sessions: '存在正在运行的会话，请先停止运行中的任务。',
+    active_turns: '存在正在运行的回合，请先等待结束或停止。',
+    patch_conflict: '补丁状态冲突，请先人工诊断，不会强制覆盖。',
+    backup_missing: '缺少可验证的原版备份，无法安全恢复。',
+    restart_required: '需要重启原引擎后重新检查。',
+    inspection_failed: '状态检查失败，请使用安装诊断排查。',
+    config_inspection_failed: '配置检查失败，无法验证模型与密钥依赖；请使用安装诊断排查。',
+    session_inspection_failed: '会话检查失败，无法验证活动回合与模型引用；请使用安装诊断排查。',
+    session_service_missing: '缺少会话查询或持久化服务，无法验证历史会话的模型依赖；请使用安装诊断排查。',
+    process_inspection_failed: '进程检查失败，无法排除其他引擎使用补丁；请使用安装诊断排查。',
+    profile_inspection_failed: '配置档检查失败，无法排除跨配置档依赖；请使用安装诊断排查。',
+    patch_inspection_failed: '补丁文件检查失败，无法验证磁盘状态；不会修改未知文件。',
+    not_removable: '当前插件状态不允许安全卸载。',
+    not_applicable: '当前状态不允许安全应用补丁。',
+    manager_unavailable: '插件管理服务不可用，请稍后重试。',
+    host_unknown: '无法验证宿主版本，不会修改未知文件。',
+    state_changed: '状态已发生变化，请刷新检查后重新打开操作并确认。',
+    apply_failed: '补丁应用未完成，请刷新检查，不要视为成功。',
+    restore_failed: '原版恢复未完成，请刷新检查，不要视为成功。',
+    remove_failed: '卸载未完成，请刷新检查并使用安装诊断排查。',
+    remove_unverified: '无法验证卸载结果，请刷新检查，不要视为成功。',
+    verify_failed: '安全验证失败，不会强制覆盖文件。',
+    busy: '维护或其他任务正在运行，请结束后刷新。',
+    confirmation_required: '安全确认已失效，请刷新检查后重新打开操作并确认。',
+    maintenance_failed: '维护失败，请刷新检查并使用安装诊断排查。',
+    inspection_unknown: '无法确认运行状态，请先停止任务并使用安装诊断排查。',
+    profile_unknown: '无法确认当前配置档，不会执行维护。',
+    cross_profile_bundle: '其他配置档也在使用此插件，请先处理跨配置档依赖。',
+    alias_dependency: '仍有会话或配置引用多密钥模型，请先切换为普通模型再检查；本预览不会自动转换。',
+    key_config_dependency: '仍有多密钥配置依赖：请先禁用 multiKey 并清理 keyEntries 配置；已保存的密钥会保留。本预览不会自动转换。',
+    expression_unknown: '存在无法安全判断的配置表达式，请先人工检查配置。',
+    other_process: '其他引擎进程可能正在使用补丁，请先停止相关进程。',
+  };
+  return (labels[blocker.code.toLowerCase()] || '安全检查未通过，请先处理运行中的任务或使用安装诊断排查。')
+    + (blocker.count ? `（${blocker.count} 项）` : '');
+}
+
+// Copy only allowlisted codes and enumerated state: unknown codes may contain secrets or paths.
+export function maintenanceDiagnostic(state) {
+  const snapshot = state.snapshot;
+  const knownCodes = new Set(['active_sessions', 'active_turns', 'patch_conflict', 'backup_missing', 'restart_required',
+    'inspection_failed', 'config_inspection_failed', 'session_inspection_failed', 'session_service_missing',
+    'process_inspection_failed', 'profile_inspection_failed', 'patch_inspection_failed', 'default_inspection_failed',
+    'agent_inspection_failed', 'activity_unverified', 'not_removable', 'not_applicable', 'manager_unavailable',
+    'host_unknown', 'state_changed', 'apply_failed', 'restore_failed', 'remove_failed', 'remove_unverified',
+    'verify_failed', 'busy', 'confirmation_required', 'maintenance_failed', 'inspection_unknown', 'profile_unknown',
+    'cross_profile_bundle', 'alias_dependency', 'key_config_dependency', 'expression_unknown', 'other_process']);
+  const diagnosticItem = item => {
+    const code = item.code.toLowerCase();
+    return { code: knownCodes.has(code) ? code : 'unknown', count: item.count };
+  };
+  return JSON.stringify({
+    status: snapshot?.phase ?? 'unknown', busy: !!state.busy, resultUnverified: !!state.error,
+    restartRequired: snapshot?.restartRequired ?? null,
+    capabilities: snapshot ? { apply: snapshot.canApply, close: snapshot.canRestoreOnly, uninstall: snapshot.canRestore } : null,
+    patches: snapshot?.patches.map(patch => patch.state) ?? [],
+    blockers: snapshot?.blockers.map(diagnosticItem) ?? [],
+    warnings: snapshot?.warnings.map(diagnosticItem) ?? [],
+  }, null, 2);
+}
+export function maintenanceWarningText(warning) {
+  const labels = {
+    alias_dependency: '旧多密钥模型选择可能影响后续使用或重启；本页不会自动切换服务或模型。',
+    key_config_dependency: '旧多密钥配置可能影响后续使用或重启；关闭会保留密钥和历史，不自动转换配置。',
+    expression_unknown: '部分配置表达式无法完整检查，请留意关闭后的使用和重启情况。',
+  };
+  const code = warning.code.toLowerCase();
+  const inspection = ['config_inspection_failed', 'session_inspection_failed', 'session_service_missing', 'process_inspection_failed', 'profile_inspection_failed', 'inspection_unknown', 'default_inspection_failed', 'agent_inspection_failed', 'activity_unverified'];
+  return (labels[code] || (inspection.includes(code) ? '检查不完整，无法确认全部依赖；这只是提醒，不会额外禁用操作。' : '部分使用情况未能验证，不等于安全；这只是提醒，不会额外禁用操作。'))
+    + (warning.count ? `（${warning.count} 项）` : '');
+}
+
+export function createMaintenanceController({ request = (...args) => fetch(...args), storage = () => globalThis.localStorage } = {}) {
+  let state = { snapshot: null, busy: false, error: '', cleanupWarning: false, patchedWarning: false };
+  let disposed = false;
+  let generation = 0;
+  const listeners = new Set();
+  const update = next => { if (disposed) return; state = { ...state, ...next }; for (const listener of listeners) listener(); };
+  async function readSnapshot(options) {
+    const response = await request(MAINTENANCE_ENDPOINT, { credentials: 'same-origin', cache: 'no-store', ...options });
+    if (!response.ok) throw new Error('Maintenance HTTP error');
+    const envelope = await response.json();
+    if (envelope?.ok !== true) throw new Error('Maintenance refused');
+    return maintenanceSnapshot(envelope.value);
+  }
+  function accept(snapshot) {
+    let cleanupWarning = false;
+    if (snapshot.phase === 'removed') {
+      for (const key of MAINTENANCE_KEYS) {
+        try { storage()?.removeItem(key); } catch { cleanupWarning = true; }
+      }
+    }
+    update({ snapshot, cleanupWarning, patchedWarning: snapshot.patches.some(patch => patch.state === 'patched'),
+      error: snapshot.phase === 'failed' ? '维护操作失败，未确认完成。请刷新检查，不要强制覆盖。' : '' });
+  }
+  async function run(action = null) {
+    if (disposed || state.busy || (action && !maintenanceCanAction(state.snapshot, action))) return;
+    const sequence = ++generation;
+    const token = state.snapshot?.token;
+    const current = () => !disposed && sequence === generation;
+    update({ busy: true, error: '' });
+    try {
+      // Recheck immediately before using the confirmed token; a changed state needs new consent.
+      let snapshot = await readSnapshot({ method: 'GET' });
+      if (!current()) return;
+      if (action) {
+        if (snapshot.token !== token || !maintenanceCanAction(snapshot, action)) {
+          accept(snapshot);
+          update({ error: '状态已发生变化或操作被阻止，未执行操作。请检查当前状态并重新打开操作并确认。' });
+          return;
+        }
+        update({ snapshot: { ...snapshot, canApply: false, canRestoreOnly: false, canRestore: false, token: null } });
+        snapshot = await readSnapshot({ method: 'POST', headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ action, token, confirmation: MAINTENANCE_CONFIRMATION }) });
+        if (!current()) return;
+      }
+      accept(snapshot);
+    } catch {
+      if (current()) update({ snapshot: null,
+        error: action ? '未能确认维护结果：连接中断、请求被拒绝或响应无效不代表成功。请刷新检查。' : '状态检查失败，请确认连接后刷新重试。' });
+    } finally { if (current()) update({ busy: false }); }
+  }
+  const operate = (action, checked) => checked === true && Object.hasOwn(ACTION_CAPABILITIES, action) ? run(action) : Promise.resolve();
+  return {
+    getSnapshot: () => state,
+    subscribe: listener => { listeners.add(listener); return () => listeners.delete(listener); },
+    activate: () => { disposed = false; generation++; update({ busy: false }); },
+    refresh: () => run(),
+    operate,
+    apply: checked => operate('apply', checked),
+    restoreOnly: checked => operate('restore-only', checked),
+    restore: checked => operate('restore-and-uninstall', checked),
+    dispose: () => { disposed = true; generation++; listeners.clear(); },
+  };
+}

package/src/maintenance.js

@@ -0,0 +1,164 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { planPatches, applyPlan, sha256 } from '../scripts/native-patches.mjs';
+
+export const BUNDLE_NAME = 'dsh-model-groups';
+// Process-local evidence survives controller replacement and module HMR, but not an
+// engine restart. The restoration marker only suppresses automatic patching: it is
+// not evidence that this process has loaded old code. A new process's runtime
+// remains unverified; checking disk must never create persistent restart state.
+const processChangesKey = Symbol.for('dsh-model-groups.maintenance.process-changes.v1');
+const processChanges = globalThis[processChangesKey] ??= new Map();
+export function maintenanceStorage(root, home) {
+  return path.join(home, BUNDLE_NAME, sha256(fs.realpathSync(root)).slice(0, 16));
+}
+export function restorationPending(root, home) {
+  return fs.existsSync(path.join(maintenanceStorage(root, home), 'restore-pending.json'));
+}
+
+/** Local-only transaction. Inspection and removal are injected to keep tests off the live host. */
+export function createMaintenance({ root, home, inspect, manager, artifacts, now = Date.now }) {
+  let phase = 'idle', busy = false, ticket;
+  const rootKey = fs.realpathSync(root);
+  const storage = maintenanceStorage(root, home);
+  const marker = path.join(storage, 'restore-pending.json');
+  const restartRequired = () => (processChanges.get(rootKey)?.length ?? 0) > 0;
+  function changeFiles(plans) {
+    try { applyPlan(plans, path.join(storage, 'backups')); }
+    finally {
+      // Record actual observed disk changes, not an attempted/no-op operation.
+      // Also retain evidence if verification later fails or a partial write survives.
+      const changes = plans.flatMap(plan => {
+        try {
+          const current = fs.readFileSync(plan.file, 'utf8');
+          return plan.source !== plan.result && current === plan.result
+            ? [{ file: plan.file, before: sha256(plan.source), after: sha256(current) }] : [];
+        } catch { return []; }
+      });
+      if (changes.length) processChanges.set(rootKey, [...(processChanges.get(rootKey) ?? []), ...changes]);
+    }
+  }
+  const patchPlans = () => planPatches(root, 'revert', artifacts);
+  const generic = (code, message) => ({ code, message });
+  async function assessment() {
+    const blockers = [];
+    let plans = [], removable = false;
+    try { plans = patchPlans(); }
+    catch { blockers.push(generic('PATCH_CONFLICT', '宿主版本或文件校验不匹配；未修改任何宿主文件，请先处理冲突。')); }
+    try {
+      const report = await inspect();
+      if (!report || !Array.isArray(report.blockers) || typeof report.fingerprint !== 'string') throw new Error('inspection');
+      blockers.push(...report.blockers);
+    } catch { blockers.push(generic('INSPECTION_FAILED', '部分配置和会话使用情况未能检查；关闭后可能需要重新配置普通模型。')); }
+    try {
+      const bundles = await manager.listBundles();
+      const bundle = bundles.find(item => item.name === BUNDLE_NAME);
+      removable = !!bundle?.removable;
+       if (!removable) blockers.push(generic('NOT_REMOVABLE', '当前插件不属于可卸载的 profile 依赖，请使用安装它的原 profile 管理器。'));
+    } catch { blockers.push(generic('MANAGER_UNAVAILABLE', '插件管理器不可用，无法安全卸载。')); }
+    // Dependency observations describe consequences, not permission to overwrite files.
+    // Only proven activity, other engines sharing the installation and file conflicts
+    // stop patch changes. Unknown observations remain visible for explicit consent.
+    const hardCodes = new Set(['patch_conflict', 'active_turns', 'other_process', 'not_removable', 'manager_unavailable']);
+    const warnings = blockers.filter(b => !hardCodes.has(b.code.toLowerCase()));
+    const hard = blockers.filter(b => hardCodes.has(b.code.toLowerCase()));
+    return { plans, blockers: hard, warnings, removable, stamp: sha256(JSON.stringify([hard, removable, plans.map(p => [p.name, sha256(p.source), !!p.updateAvailable, sha256(JSON.stringify(p.artifact))])])) };
+  }
+  function view(report, executing = false) {
+    const valid = report.plans.length > 0 && !report.blockers.some(b => b.code.toLowerCase() === 'patch_conflict');
+    const dependencies = report.blockers.filter(b => !['not_removable', 'manager_unavailable'].includes(b.code.toLowerCase()));
+    const installBlockers = dependencies;
+    const available = (!busy || executing) && phase !== 'removed';
+    return { phase, restartRequired: restartRequired(), patches: report.plans.map(p => ({ name: p.name, state: p.state, updateAvailable: !!p.updateAvailable })), blockers: report.blockers, warnings: report.warnings,
+      token: null, canApply: available && valid && installBlockers.length === 0 && report.plans.some(p => p.state === 'pristine' || p.updateAvailable),
+      canRestoreOnly: available && valid && dependencies.length === 0 && report.plans.some(p => p.state === 'patched'),
+      canRestore: available && valid && report.blockers.length === 0,
+      notice: '关闭会保留密钥和聊天记录，不自动更换服务。旧多密钥选择可能失效，旧配置可能影响重启；使用情况未完整检查时仍可确认继续。普通插件列表卸载不会还原补丁。' };
+  }
+  async function snapshot() {
+    const report = await assessment();
+    const value = view(report);
+    if (value.canRestore || value.canRestoreOnly || value.canApply) {
+      if (!ticket || ticket.stamp !== report.stamp || ticket.expires < now()) ticket = { token: crypto.randomBytes(32).toString('hex'), stamp: report.stamp, expires: now() + 120000 };
+      value.token = ticket.token;
+    }
+    return value;
+  }
+  async function restore(input) {
+    if (busy) throw generic('BUSY', '已有维护任务正在执行。');
+    if (!['apply', 'restore-only', 'restore-and-uninstall'].includes(input?.action) || input?.confirmation !== 'CONFIRM PATCH OPERATION' ||
+      !ticket || typeof input.token !== 'string' || input.token !== ticket.token || ticket.expires < now()) {
+      throw generic('CONFIRMATION_REQUIRED', '确认已失效，请重新检查并明确确认。');
+    }
+    const expected = ticket; ticket = undefined;
+    const action = input.action;
+    busy = true;
+    let locked = false;
+    const lock = path.join(storage, 'patch.lock');
+    try {
+      fs.mkdirSync(storage, { recursive: true, mode: 0o700 });
+      // Same inter-process lock as automatic installation. Never remove somebody else's lock.
+      fs.mkdirSync(lock, { mode: 0o700 }); locked = true;
+      const report = await assessment();
+      const permissions = view(report, true);
+       const permitted = action === 'apply' ? permissions.canApply : action === 'restore-only' ? permissions.canRestoreOnly : permissions.canRestore;
+       if (!permitted || report.stamp !== expected.stamp) throw generic('STATE_CHANGED', '文件或任务状态发生变化，请确认没有任务运行后重试。');
+      if (action === 'apply') {
+        changeFiles(planPatches(root, 'apply', artifacts));
+        if (!patchPlans().every(p => p.state === 'patched' && !p.updateAvailable)) throw generic('VERIFY_FAILED', '补丁验证失败。');
+        // Never delete a computed or unverified path; only this exact owned marker.
+        if (fs.existsSync(marker)) {
+          const stat = fs.lstatSync(marker);
+          if (!stat.isFile() || stat.isSymbolicLink()) throw generic('VERIFY_FAILED', '恢复标记异常。');
+          fs.unlinkSync(marker);
+        }
+        phase = 'applied';
+        return view(await assessment());
+      }
+      fs.writeFileSync(marker, JSON.stringify({ version: 1, purpose: 'explicit-restore-and-uninstall' }), { mode: 0o600 });
+      // Fresh synchronous planning checks concurrent target edits again; applyPlan performs an additional check.
+      changeFiles(patchPlans());
+      if (!patchPlans().every(p => p.state === 'pristine')) throw generic('VERIFY_FAILED', '原版文件复查失败，未宣告卸载成功。');
+      phase = 'restored';
+      if (action === 'restore-only') return view(await assessment());
+      phase = 'removing';
+      const result = await manager.removeBundle(BUNDLE_NAME);
+      if (!result || result.application !== 'applied' || result.error || (result.packageResult && (result.packageResult.exitCode !== 0 || result.packageResult.timedOut))) throw generic('REMOVE_FAILED', '已确认原版文件，但插件卸载失败。请保留恢复标记并在插件列表中重试卸载；是否需要重启以文件修改记录为准。');
+      const remaining = (await manager.listBundles()).find(item => item.name === BUNDLE_NAME);
+      if (remaining?.installed || remaining?.removable || remaining?.enabled) throw generic('REMOVE_UNVERIFIED', '尚未确认插件依赖已移除，请检查插件列表；补丁不会自动重新安装。');
+      if (!patchPlans().every(p => p.state === 'pristine')) throw generic('VERIFY_FAILED', '卸载后宿主文件再次变化，不能确认完整恢复。');
+      phase = 'removed';
+      return { phase, restartRequired: restartRequired(), patches: patchPlans().map(p => ({ name: p.name, state: p.state, updateAvailable: !!p.updateAvailable })), blockers: [], canRestore: false, canRestoreOnly: false, canApply: false, token: null,
+        notice: '已确认原版文件和插件依赖移除状态。密钥、历史和安全备份未删除；运行时状态未验证，是否需要重启以本进程实际文件修改记录为准。' };
+    } catch (error) {
+      phase = 'failed';
+      throw ['STATE_CHANGED', 'VERIFY_FAILED', 'REMOVE_FAILED', 'REMOVE_UNVERIFIED'].includes(error?.code) ? error : generic('MAINTENANCE_FAILED', '维护未完成。未宣告成功；如已还原文件，恢复标记会阻止自动重新打补丁。请检查后重试。');
+    } finally {
+      busy = false;
+      if (locked) fs.rmdirSync(lock);
+    }
+  }
+  return { snapshot, restore, isBusy: () => busy };
+}
+
+/** Every request requires the host's authenticated owner admission, even on stock DSH. */
+export function maintenanceHandler(controller, connection) {
+  return async (req, res) => {
+    const send = (status, body) => { res.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store', 'x-content-type-options': 'nosniff' }); res.end(JSON.stringify(body)); };
+    try {
+      const admission = connection.admit(req);
+      if (!admission?.peer || admission.peer.principal?.kind !== 'owner') return send(admission?.rejection || 403, { ok: false, error: { code: 'FORBIDDEN', message: '需要已登录的主机所有者。' } });
+      if (req.method === 'GET') return send(200, { ok: true, value: await controller.snapshot() });
+      if (req.method !== 'POST') return send(405, { ok: false, error: { code: 'METHOD', message: '不支持此操作。' } });
+      if (!/^application\/json(?:;|$)/i.test(req.headers['content-type'] || '')) return send(415, { ok: false, error: { code: 'CONTENT_TYPE', message: '只接受 JSON。' } });
+      let body = '', length = 0;
+      for await (const chunk of req) { length += Buffer.byteLength(chunk); if (length > 4096) return send(413, { ok: false, error: { code: 'BODY_LIMIT', message: '请求过大。' } }); body += chunk; }
+      let input;
+      try { input = JSON.parse(body); } catch { return send(400, { ok: false, error: { code: 'JSON', message: '请求格式错误。' } }); }
+      return send(200, { ok: true, value: await controller.restore(input) });
+    } catch (error) {
+      return send(409, { ok: false, error: { code: error?.code || 'FAILED', message: error?.code ? error.message : '检查或维护失败，请重新检查。' } });
+    }
+  };
+}

package/src/settings-page.css

@@ -0,0 +1,21 @@
+.mg-maintenance{box-sizing:border-box;display:flex;flex-direction:column;gap:12px;max-width:720px;min-width:0;color:var(--dsw-alias-label-primary);font-family:inherit;font-size:13px;line-height:1.5}
+.mg-maintenance h2{margin:0;font-size:18px;font-weight:600;line-height:26px}
+.mg-maintenance h3{margin:0;font-size:14px;font-weight:600;line-height:22px}
+.mg-maintenance p{margin:0;color:var(--dsw-alias-label-tertiary);font-size:13px;line-height:20px}
+.mg-maintenance-card{display:flex;flex-direction:column;gap:12px;min-width:0;border:.5px solid var(--dsw-alias-settings-card-stroke);border-radius:var(--dsw-radius-xl,12px);background:var(--dsw-alias-settings-card-fill);padding:16px}
+.mg-maintenance-row{display:flex;align-items:center;justify-content:space-between;gap:12px;flex-wrap:wrap}
+.mg-maintenance ul{padding-left:20px;margin:0;color:var(--dsw-alias-label-secondary);overflow-wrap:anywhere}
+.mg-maintenance-actions{display:flex;flex-wrap:wrap;gap:10px;align-items:center}
+.mg-maintenance button{align-self:flex-start;font:inherit;font-weight:500;line-height:20px;color:var(--dsw-alias-label-primary);background:var(--dsw-alias-fill-tsp-secondary);border:.5px solid var(--dsw-alias-settings-card-stroke);border-radius:var(--dsw-radius-sm,6px);padding:8px 14px;min-height:40px;cursor:pointer;white-space:normal}
+.mg-maintenance .mg-maintenance-primary:not(:disabled){border-color:var(--dsw-alias-state-business-primary);font-weight:600}
+.mg-maintenance .mg-maintenance-secondary{font-size:12px}
+@media(hover:hover){.mg-maintenance button:not(:disabled):hover{background:var(--dsw-alias-interactive-bg-hover)}}
+.mg-maintenance button:disabled{color:var(--dsw-alias-label-tertiary);background:var(--dsw-alias-fill-tsp-secondary);cursor:not-allowed;opacity:1}
+.mg-maintenance .mg-maintenance-danger:not(:disabled),.mg-maintenance .mg-maintenance-error{color:var(--dsw-alias-state-error-primary)}
+.mg-maintenance .mg-maintenance-help{color:var(--dsw-alias-label-secondary)}
+.mg-maintenance-dialog{display:flex;flex-direction:column;gap:12px;border:1px solid var(--dsw-alias-state-business-primary);border-radius:var(--dsw-radius-sm,6px);padding:16px}
+.mg-maintenance-warning{padding:10px;border-left:3px solid var(--dsw-alias-state-business-primary)}
+.mg-maintenance summary{cursor:pointer;font-weight:500;min-height:28px}
+.mg-maintenance details[open]>*+*{margin-top:12px}
+.mg-maintenance :focus-visible{outline:2px solid var(--dsw-focus-ring-color,var(--dsw-alias-state-business-primary));outline-offset:3px}
+@media(max-width:480px){.mg-maintenance-card,.mg-maintenance-dialog{padding:12px}.mg-maintenance button{max-width:100%}}

package/src/settings-page.js

@@ -0,0 +1,56 @@
+export function ModelGroupsSettingsPage() {
+  const h = react.createElement;
+  const controller = react.useMemo(() => createMaintenanceController(), []);
+  const state = react.useSyncExternalStore(controller.subscribe, controller.getSnapshot, controller.getSnapshot);
+  const [pending, setPending] = react.useState(null);
+  const [copyStatus, setCopyStatus] = react.useState('');
+  const confirmationId = react.useId();
+  react.useEffect(() => { controller.activate(); controller.refresh(); return () => controller.dispose(); }, [controller]);
+  const snapshot = state.snapshot;
+  const phaseLabels = { idle: '检查完成，可选择操作', applied: '多密钥已应用（磁盘状态）', restored: '多密钥已关闭，插件仍保留（磁盘状态）', removing: '正在卸载，尚未确认完成', removed: '已确认关闭多密钥并卸载插件', failed: '维护失败，未确认完成' };
+  const updatesAvailable = snapshot?.patches.some(patch => patch.updateAvailable) ?? false;
+  const statusLabel = snapshot?.phase === 'idle'
+    ? snapshot.patches.length && snapshot.patches.every(patch => patch.state === 'patched') ? '多密钥已启用（磁盘状态）'
+      : snapshot.patches.length && snapshot.patches.every(patch => patch.state === 'pristine') ? '多密钥已关闭（磁盘状态）' : '磁盘状态待处理，请查看操作限制'
+    : phaseLabels[snapshot?.phase];
+  const patchLabels = { patched: '已应用', pristine: '原版', conflict: '冲突（不会强制覆盖）' };
+  const actions = [['apply', updatesAvailable ? '更新多密钥补丁' : '启用多密钥'],  ['restore-only', '关闭多密钥'], ['restore-and-uninstall', '关闭并卸载插件']];
+  const anyAllowed = actions.some(([action]) => maintenanceCanAction(snapshot, action));
+  const refresh = () => { setPending(null); controller.refresh(); };
+  const confirm = () => { const action = pending; setPending(null); if (action) controller.operate(action, true); };
+  const copy = async () => {
+    try { await globalThis.navigator.clipboard.writeText(maintenanceDiagnostic(state)); setCopyStatus('已复制脱敏诊断'); }
+    catch { setCopyStatus('无法复制，请检查浏览器剪贴板权限。'); }
+  };
+  return h('section', { className: 'mg-maintenance', 'aria-label': '模型分组设置', 'aria-busy': state.busy },
+    h('h2', null, '模型分组 · 多密钥管理'),
+    h('p', null, '选择操作，再确认一次即可。不会调用 AI，不会显示或删除 API 密钥。'),
+    h('section', { className: 'mg-maintenance-card', 'aria-label': '当前状态' },
+      h('div', { className: 'mg-maintenance-row' }, h('h3', null, '当前状态'), h('button', { type: 'button', disabled: state.busy, onClick: refresh }, state.busy ? '处理中…' : '刷新检查')),
+      h('p', { role: 'status', 'aria-live': 'polite', className: 'mg-maintenance-help' }, state.busy ? '正在检查或执行维护，请勿关闭或重复操作。' : snapshot ? statusLabel : '尚无可验证状态，请刷新检查。'),
+      state.error && h('p', { role: 'alert', className: 'mg-maintenance-error' }, state.error),
+      state.patchedWarning && h('p', { role: 'alert', className: 'mg-maintenance-error' }, '警告：从普通插件列表卸载只移除插件，仍会留下宿主补丁，可能造成升级、文件冲突及旧多密钥模型依赖问题。请使用这里的“关闭并卸载插件”。'),
+      snapshot?.restartRequired && h('p', { role: 'status' }, '本进程已实际修改宿主文件，需要重启原引擎并刷新；页面刷新或插件重载不等于进程重启。'),
+      updatesAvailable && h('p', { role: 'status' }, '多密钥补丁有更新可用；确认后将备份、校验并更新已识别的旧补丁。'),
+      snapshot?.phase === 'removed' && h('p', { role: 'status' }, '卸载已确认：仅清理本插件的两个浏览器显示偏好，密钥、历史和备份均保留。'),
+      snapshot?.warnings.length > 0 && h('p', { className: 'mg-maintenance-warning', role: 'status' }, '部分使用情况未验证，关闭前请阅读提示；检查提醒不会额外禁用操作。'),
+      snapshot?.blockers.length > 0 && h('div', { role: 'alert' }, h('strong', null, '操作限制（各按钮以安全权限为准）'), h('ul', null, ...snapshot.blockers.map((blocker, index) => h('li', { key: index }, maintenanceBlockerText(blocker))))),
+      state.cleanupWarning && h('p', { role: 'status' }, '卸载已确认，但浏览器阻止清理本插件的显示偏好；其他数据未受影响。')),
+    h('section', { className: 'mg-maintenance-card', 'aria-label': '多密钥操作' },
+      h('h3', null, '多密钥操作'),
+      h('div', { className: 'mg-maintenance-actions' }, ...actions.map(([action, label]) => h('button', { key: action, type: 'button', className: action === 'restore-and-uninstall' ? 'mg-maintenance-secondary mg-maintenance-danger' : 'mg-maintenance-primary', disabled: state.busy || !!pending || !maintenanceCanAction(snapshot, action), onClick: () => setPending(action) }, label))),
+      !anyAllowed && h('p', null, '请刷新检查或处理上方操作限制。检查提醒本身不会禁用按钮。'),
+      pending && h('div', { role: 'dialog', 'aria-labelledby': confirmationId, 'aria-describedby': `${confirmationId}-help`, className: 'mg-maintenance-dialog' },
+        h('h3', { id: confirmationId }, `确认${actions.find(([action]) => action === pending)[1]}？`),
+        h('p', { id: `${confirmationId}-help` }, pending === 'apply' ? '将备份、校验并修改宿主文件以启用多密钥。不会自动换服务或模型。请保存草稿、停止任务，完成后重启原引擎。' : '将校验并恢复宿主原版，关闭多密钥。密钥、配置和历史保留，不自动换服务或模型；旧多密钥选择和配置可能影响后续使用或重启。请保存草稿、停止任务，完成后重启原引擎。'),
+        h('p', null, '请先停止所有任务。部分使用情况未能检查不等于安全；检查提醒不会替代您的判断。'),
+        pending === 'restore-and-uninstall' && h('p', null, '确认原版恢复成功后才卸载插件；只有确认卸载完成才清理本插件的两个浏览器显示偏好。连接中断不代表成功。'),
+        h('div', { className: 'mg-maintenance-actions' }, h('button', { type: 'button', onClick: () => setPending(null) }, '取消'), h('button', { type: 'button', disabled: state.busy || !maintenanceCanAction(snapshot, pending), onClick: confirm }, '确认执行')))),
+    h('details', { className: 'mg-maintenance-card' },
+      h('summary', null, '检查详情与脱敏诊断'),
+      h('p', null, '这里只验证磁盘和安全权限，运行时是否已切换未知。每次确认后会重新检查；状态变化需重新确认。未知文件不会强制覆盖，检查不完整仅提醒；操作仍以各自安全权限为准。'),
+      snapshot?.warnings.length > 0 && h('ul', null, ...snapshot.warnings.map((warning, index) => h('li', { key: index }, maintenanceWarningText(warning)))),
+      snapshot && h('ul', null, ...snapshot.patches.map((patch, index) => h('li', { key: index }, `宿主文件 ${index + 1}：${patchLabels[patch.state]}${patch.updateAvailable ? '（更新可用）' : ''}`))),
+      h('button', { type: 'button', onClick: copy }, '复制脱敏诊断'),
+      h('p', { role: 'status' }, copyStatus)));
+}