dsh-waifu-agents 0.3.1 → 0.3.2

package/client.js

@@ -199,7 +199,8 @@ window.__ModuleLoader__.load({
         name: '名字',
         description: '简述',
         bodyPlaceholder: '只写她独有的部分；公共条款在骨架里',
-        autosave: '改动会在离开输入框时自动保存',
+        save: '保存',
+        saveHint: '改动要点「保存」才会写入',
         nameDrivesFile: '文件名会跟着「名字」走',
         saving: '保存中…',
         saved: '已保存',
@@ -533,7 +534,8 @@ window.__ModuleLoader__.load({
         name: 'Name',
         description: 'Summary',
         bodyPlaceholder: 'Only her own part; the shared clauses live in the skeleton',
-        autosave: 'Edits are written when the field loses focus',
+        save: 'save',
+        saveHint: 'Changes are written when you press Save',
         nameDrivesFile: 'The file name follows this name',
         saving: 'Saving…',
         saved: 'Saved',
@@ -1603,22 +1605,30 @@ window.__ModuleLoader__.load({
      * 提示词。`Confirm` / `Alert` 那种一句话对话框仍然走平台，两者不冲突：
      * 这里只借用同一层遮罩色和同一套主题 token。
      *
-     * 三条收尾路径都要有：右上角的关闭、点遮罩、Esc。少一条，用户就会在
-     * 某一次编辑后发现"关不掉"，而那正是弹窗最容易招人烦的地方。
+     * 收尾路径分两档。未锁定时三条都要有：右上角的关闭、点遮罩、Esc——少一
+     * 条，用户就会在某一次编辑后发现"关不掉"，而那正是弹窗最容易招人烦的地
+     * 方。锁定（`locked`）时只剩显式按钮：编辑器正攥着一份未保存的草稿，一
+     * 次走神的点击落在遮罩上、或者一个惯性 Esc，就把整段正文无声丢掉——这
+     * 种"没有确认、没有恢复"的丢失比关不掉恶劣得多，所以两个编辑器都锁。
      */
-    function Sheet({ open, title, hint, width, t, onClose, footer, children }) {
+    function Sheet({ open, title, hint, width, t, onClose, footer, children, locked }) {
       React.useEffect(() => {
         if (open !== true) return undefined;
+        if (locked === true) return undefined;
         const onKey = (event) => {
           if (event.key === 'Escape') onClose();
         };
         document.addEventListener('keydown', onKey);
         return () => document.removeEventListener('keydown', onKey);
-      }, [open, onClose]);
+      }, [open, onClose, locked]);
       if (open !== true) return null;
       return h(
         'div',
-        { style: { ...L.overlay, zIndex: 60 }, onClick: onClose },
+        {
+          style: { ...L.overlay, zIndex: 60 },
+          // 锁定时遮罩不再接 onClose：点外面什么也不发生，关窗只能走按钮。
+          onClick: locked === true ? undefined : onClose,
+        },
         h(
           'div',
           {
@@ -1917,8 +1927,8 @@ window.__ModuleLoader__.load({
      * a draft with unsaved keystrokes in it, and a preview that reads from the
      * draft can never be what the model sees. This one is fetched from the Host
      * (`get` again), so it shows the file as it is on disk with the skeleton
-     * poured in — and `openPreview` waits for the autosave the click itself
-     * triggered, so "on disk" means "including what you just typed".
+     * poured in — "on disk" now means "the last version you pressed Save on";
+     * edits still in the editor are deliberately not in it.
      */
     function PreviewWindow({ open, title, text, loading, error, t, onClose }) {
       if (open !== true) return null;
@@ -1998,7 +2008,20 @@ window.__ModuleLoader__.load({
       );
     }
 
-    function Editor({ draft, t, busy, onPatch, onCommit, tall }) {
+    /*
+     * 人设编辑器：弹窗里的一张表，改动**不**自动保存。
+     *
+     * 曾经每个输入框失焦就写一次盘（"改动会在离开输入框时自动保存"）。
+     * 那意味着"保存"这个动作不可见：点谁、路过谁都会触发一次写入，而
+     * 写一半想去看看别人、再回来的路上一句话已经被存成了半句。现在写入
+     * 只有一个入口——下面的「保存」按钮；关掉窗口（× 或「取消」）丢掉
+     * 没保存的改动，文件保持上一次保存的样子。
+     *
+     * `dirty` 由调用方算（`draftKeyOf(draft) !== draft.savedKey`）：它让
+     * 「保存」在没有改动时是灰的，替代旧模型里"没改动就不发请求"的
+     * 静默去重——去重还在（`save` 里），只是用户现在也看得见。
+     */
+    function Editor({ draft, t, busy, onPatch, onSave, onCancel, dirty, tall }) {
       const loading = draft.loading === true;
       const field = (label, ...controls) => h('div', { style: L.field }, h('span', { style: L.label }, label), ...controls);
       const text = draft.body ?? '';
@@ -2017,7 +2040,6 @@ window.__ModuleLoader__.load({
                   value: draft.name ?? '',
                   disabled: busy,
                   onChange: (event) => onPatch({ name: event.target.value }),
-                  onBlur: onCommit,
                 }),
               ),
               field(
@@ -2027,7 +2049,6 @@ window.__ModuleLoader__.load({
                   value: draft.description ?? '',
                   disabled: busy,
                   onChange: (event) => onPatch({ description: event.target.value }),
-                  onBlur: onCommit,
                 }),
               ),
               field(
@@ -2037,7 +2058,6 @@ window.__ModuleLoader__.load({
                   value: draft.group ?? '',
                   disabled: busy,
                   onChange: (event) => onPatch({ group: event.target.value }),
-                  onBlur: onCommit,
                 }),
               ),
               field(
@@ -2046,10 +2066,7 @@ window.__ModuleLoader__.load({
                   checked: (draft.template ?? '') === SKELETON_FILE,
                   disabled: busy,
                   title: t('useSkeleton'),
-                  onChange: (next) => {
-                    onPatch({ template: next ? SKELETON_FILE : '' });
-                    onCommit();
-                  },
+                  onChange: (next) => onPatch({ template: next ? SKELETON_FILE : '' }),
                 }),
               ),
               /*
@@ -2064,7 +2081,6 @@ window.__ModuleLoader__.load({
                 disabled: busy,
                 placeholder: t('bodyPlaceholder'),
                 onChange: (event) => onPatch({ body: event.target.value }),
-                onBlur: onCommit,
               }),
               (draft.problems ?? []).length > 0
                 ? h(
@@ -2074,7 +2090,17 @@ window.__ModuleLoader__.load({
                     ...(draft.problems ?? []).map((line, index) => h('div', { key: index, style: L.error }, line)),
                   )
                 : null,
-              h('span', { style: L.hint }, `${t('autosave')} · ${t('nameDrivesFile')}`),
+              h(
+                'div',
+                { style: { ...L.bar, justifyContent: 'space-between', marginTop: '4px' } },
+                h('span', { style: L.hint }, `${t('saveHint')} · ${t('nameDrivesFile')}`),
+                h(
+                  'div',
+                  { style: L.bar },
+                  h(Btn, { variant: 'toolbar', disabled: busy, onClick: onCancel }, t('cancel')),
+                  h(Btn, { variant: 'primary', disabled: busy || dirty === false, onClick: onSave }, t('save')),
+                ),
+              ),
             ),
       );
     }
@@ -2291,9 +2317,9 @@ window.__ModuleLoader__.load({
             'aria-label': t('preview'),
             /*
              * Not disabled while `busy`. Reading does not fight the writer, and
-             * the click that opened this also triggered the autosave (blur
-             * fires first) — disabling here would swallow exactly that click.
-             * `openPreview` waits for the write instead.
+             * an explicit-save editor means the click never starts a write —
+             * the preview shows the last saved version, unsaved keystrokes
+             * stay in the editor where they belong.
              */
             disabled: locked,
             style: { padding: '0 6px' },
@@ -2713,6 +2739,8 @@ window.__ModuleLoader__.load({
                 width: '860px',
                 t,
                 onClose: onCancelDraft,
+                // 与人设编辑器同一档：草稿只认显式的取消/保存。
+                locked: true,
               },
               h(TeamDraftCard, {
                 draft,
@@ -3635,7 +3663,8 @@ window.__ModuleLoader__.load({
         onImportClick,
         onDownloadTemplate,
         onPatchDraft,
-        onCommit,
+        onSave,
+        dirty,
         onCloseDraft,
         page,
         pageSize,
@@ -3803,8 +3832,10 @@ window.__ModuleLoader__.load({
                 width: '820px',
                 t,
                 onClose: onCloseDraft,
+                // 点遮罩、Esc 都不收：草稿只认显式的取消/保存。
+                locked: true,
               },
-              h(Editor, { draft, t, busy, onPatch: onPatchDraft, onCommit, tall: true }),
+              h(Editor, { draft, t, busy, onPatch: onPatchDraft, onSave, onCancel: onCloseDraft, dirty, tall: true }),
             )
           : null,
         pageCount > 1
@@ -3935,12 +3966,12 @@ window.__ModuleLoader__.load({
       const idAlias = React.useRef(new Map());
       const fileInput = React.useRef(null);
       /**
-       * The autosave currently in flight, if any.
+       * The explicit save currently in flight, if any.
        *
-       * Clicking the eye blurs the textarea first, and blur is what starts the
-       * save — so without this the preview races the write it just triggered
-       * and shows the file one keystroke behind. Preview is a read of the disk,
-       * and a read has to wait for the write in front of it.
+       * Saves start only from the editor's Save button now, so there is no
+       * blur race to lose — but a second click on Save while one write is
+       * still running must not start a duplicate, and `openPreview` keeps
+       * waiting on this slot so a save and a read can never interleave.
        */
       const savingRef = React.useRef(null);
 
@@ -4513,6 +4544,13 @@ window.__ModuleLoader__.load({
               savedKey: written,
             });
           }
+          /*
+           * 保存成功即收窗。写盘已经完成，草稿没有值得留下的东西——这与
+           * 团队编辑器的「成功即 `setTeamDraft(null)`」是同一条约定；留窗
+           * 是失焦自动保存时代的习惯，那时窗口必须开着等下一次失焦。
+           * 失败路径不动：弹窗留在原地，错误贴在窗内。
+           */
+          putDraft(null);
           await load();
           await loadRoster();
         } catch (failure) {
@@ -4527,7 +4565,13 @@ window.__ModuleLoader__.load({
         }
       }
 
-      /** Blur, row switch and unmount all funnel through here. */
+      /**
+       * 编辑器「保存」按钮的唯一入口。
+       *
+       * 曾经失焦也会走到这里（blur → commit），如今唯一的调用方是按钮：
+       * 写盘必须是人按下去的那个动作。`save` 自己做去重——草稿与上一次
+       * 保存一致时不发请求——所以连点两下、或者没改就点，都是空操作。
+       */
       const commit = React.useCallback(() => {
         const current = draftRef.current;
         if (current === null || current.loading === true) return;
@@ -4540,8 +4584,8 @@ window.__ModuleLoader__.load({
         });
       }, []);
 
+      /* 关窗即放弃：没有点「保存」的改动一个字都不落盘。 */
       function closeRow() {
-        commit();
         showRow(null);
         putDraft(null);
         setDialog(null);
@@ -4560,8 +4604,8 @@ window.__ModuleLoader__.load({
         const id = item.id;
         setPeek({ id, name: item.name ?? id, loading: true, text: '', error: '' });
         try {
-          // The blur that opened this window already kicked off a save; reading
-          // first would answer with the previous version of the file.
+          // A save pressed moments ago may still be in flight; reading first
+          // would answer with the previous version of the file.
           if (savingRef.current !== null) await savingRef.current;
           const payload = await post({ op: 'get', id, assembled: true });
           setPeek((prev) =>
@@ -4583,7 +4627,6 @@ window.__ModuleLoader__.load({
           closeRow();
           return;
         }
-        commit();
         setDialog(null);
         setNote(null);
         showRow(item.id);
@@ -4631,7 +4674,6 @@ window.__ModuleLoader__.load({
           closeRow();
           return;
         }
-        commit();
         setDialog(null);
         setNote(null);
         showRow(NEW);
@@ -4658,7 +4700,6 @@ window.__ModuleLoader__.load({
           closeRow();
           return;
         }
-        commit();
         showRow(SKELETON);
         setNote(null);
         putSkeletonDraft({ text: '', slots: 0, nameSlots: 0, problems: [], rev: null, loading: true });
@@ -5569,8 +5610,10 @@ window.__ModuleLoader__.load({
               onImportClick: () => fileInput.current?.click(),
               onDownloadTemplate: downloadTemplate,
               onPatchDraft: patchDraft,
-              onCommit: commit,
-              // Closing the editor window: commit what was typed, then drop the draft.
+              // 显式保存：只有按钮会写盘。关窗（onCloseDraft）丢掉未保存的改动。
+              onSave: commit,
+              dirty: draft !== null && draft.savedKey !== undefined && draftKeyOf(draft) !== draft.savedKey,
+              // Closing the editor window: drop the draft without writing.
               onCloseDraft: closeRow,
               onOpenSkeleton: openSkeleton,
               skeletonDraft,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-waifu-agents",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "type": "module",
   "description": "Registers every *.md in a persona directory as an agent preset, and manages them from the Plugins settings page.",
   "license": "MIT",

package/panel-ops.js

@@ -171,13 +171,34 @@ export function installPanelOps(ctx, deps) {
    * 回答的问题——`registryToken` 保持指向我们登记时的那一个，复核时身份对不上
    * 就一律回 `unreadable`。
    *
-   * 解析时连续读两次，是因为服务面可能只是个别名 getter：两次读到不同对象
-   * 就说明这里根本给不出稳定身份，令牌留空，此后所有复核都是 `unreadable`。
-   * 宁可全部看不清，也不要拿一个每次访问都变的引用去当证据。
+   * 解析时连续读两次，是为了验证服务面给得出稳定身份。这里有个真宿主
+   * （2026-11-01 诊断落盘实锤）教会我们的坑：cordis 对带 tracker 的服务，
+   * 每次属性访问都现包一层 traceable 代理（`createTraceable`）——裸比对象
+   * 身份，两次**永远**不相等，令牌会被永久置空，此后所有「确认摘除」都是
+   * `unreadable`，改一个人设就弹一次「注销失败」。所以身份比的是解包后的
+   * 底层服务对象（cordis 在代理上留了官方开瓶器，见 {@link registryIdentity}）；
+   * 底层两次都同一个，才发令牌。宁可全部看不清，也不要拿一个每次访问都
+   * 换底的引用去当证据。
    */
   let registryRef = null;
   let registryToken = null;
 
+  /**
+   * 解到 cordis traceable 包装下的底层服务对象。
+   *
+   * cordis 的 traceable 代理专门留了这个读口：读
+   * `Symbol.for("cordis.original")` 返回代理目标（真正的服务对象）；不是
+   * 包装就是普通对象，符号读出来是 `undefined`，原样返回。用全局注册表
+   * 符号而不是 import，是为了不对宿主的模块布局做硬依赖。
+   *
+   * @param {object} value 属性访问刚拿到的（可能是包装的）服务对象
+   * @returns {object} 底层服务对象
+   */
+  function registryIdentity(value) {
+    const inner = value[Symbol.for("cordis.original")];
+    return inner === undefined || inner === null ? value : inner;
+  }
+
   /**
    * @returns {object | null} 本实例登记用的 registry（可能还没就绪）
    */
@@ -186,8 +207,9 @@ export function installPanelOps(ctx, deps) {
     const first = ctx.agentPresets;
     if (first === undefined || first === null) return null;
     const second = ctx.agentPresets;
+    const identity = registryIdentity(first);
     registryRef = first;
-    registryToken = first === second ? registryTokenOf(first) : null;
+    registryToken = identity === registryIdentity(second) ? registryTokenOf(identity) : null;
     return registryRef;
   }