dsh-waifu-agents 0.3.0 → 0.3.1

package/README.md

@@ -84,11 +84,13 @@ group: 组名
 几条习惯：
 
 - 编辑是**离开输入框自动保存**，没有保存按钮。
-- 只有行首的 **▸** 会展开编辑器，点名字不会。
+- 新增与编辑都开在**窗口**里（团队编辑器同样）：关掉窗口就是保存完，名册本身不会被挤走。
+- 只有行首的 **▸** 会打开编辑窗口，点名字不会。
 - 行尾的**眼睛**看组装后的成品（模型真正收到的那份）。
 - 改名字时**文件名自动跟着变**；改名不会丢正文。
 - 隐藏是改名成 `.md.off`，正文还在，随时取消隐藏。
 - 会动数据的事都会先弹一次确认。
+- 新建任务时那一列人设的顺序是：**默认人设 → 有分组的人设（按组名）→ 没分组的人设**。组内仍按「拖拽排序」的位置。
 
 ## 聊天模式与工作模式
 
@@ -180,6 +182,8 @@ group: 组名
 
 **某一行提示「激活失败」「ID 占用冲突」？** 多半是热重载时新旧实例并存，**完全退出 DSH 再启动**，提示消失就没事。
 
+**改完插件后整个面板打不开（或一片空白）？** 热重载时新旧两个实例会抢同一条接口地址，新版有可能一直没抢到。插件现在会自己重试半秒多，还失败就在日志里留一句「面板路由没注册上」。真的看到那句，**完全退出 DSH 再启动**就能恢复——人设、记忆、团队都没受影响，丢的只是那一版的面板。
+
 **保存被拒，说「磁盘上变过」？** 这行在别处被改过了，重新打开载入最新内容再改一次（被拒时磁盘上什么都没写）。
 
 **拖不动行？** 「拖拽排序」每次打开面板都是关的，在工具条里打开；开着时行内按钮会一起锁住。

package/client.js

@@ -95,6 +95,9 @@ window.__ModuleLoader__.load({
         tabMemory: '记忆',
         search: '搜索名字、简述或正文…',
         add: '新增',
+        /* 两个编辑器的窗口标题：'新增人设' / '编辑人设'。 */
+        personaNew: '新增人设',
+        personaEdit: '编辑人设',
         import: '导入 md',
         exportAll: '导出全部',
         exportOne: '导出这一条',
@@ -433,6 +436,8 @@ window.__ModuleLoader__.load({
         tabMemory: 'Memory',
         search: 'Search name, summary or body…',
         add: 'New',
+        personaNew: 'New persona',
+        personaEdit: 'Edit persona',
         import: 'Import md',
         exportAll: 'Export all',
         exportOne: 'Export this file',
@@ -1036,6 +1041,26 @@ window.__ModuleLoader__.load({
         borderRadius: 'var(--dsw-radius-panel, 12px)',
         background: 'var(--dsw-alias-bg-layer-2)',
       },
+      /*
+       * The wide dialog behind `Sheet`. Same surface as `dialog`, but its height
+       * is capped and its body scrolls: a persona body can be arbitrarily long,
+       * and a window taller than the viewport puts the close button off screen.
+       */
+      sheet: {
+        display: 'flex',
+        flexDirection: 'column',
+        gap: '12px',
+        maxWidth: 'calc(100vw - 48px)',
+        maxHeight: '86vh',
+        padding: '16px',
+        border: '1px solid var(--dsw-alias-border-l2)',
+        borderRadius: 'var(--dsw-radius-panel, 12px)',
+        background: 'var(--dsw-alias-bg-layer-2)',
+        boxSizing: 'border-box',
+        boxShadow: '0 18px 48px rgba(0, 0, 0, 0.28)',
+      },
+      sheetHead: { display: 'flex', alignItems: 'flex-start', gap: '8px' },
+      sheetBody: { display: 'flex', flexDirection: 'column', gap: '10px', overflow: 'auto', minHeight: 0 },
       dragging: { opacity: 0.45 },
       reorderRow: { cursor: 'grab', userSelect: 'none' },
       dropTarget: { borderColor: 'var(--dsw-alias-state-business-primary)', borderStyle: 'dashed' },
@@ -1569,6 +1594,67 @@ window.__ModuleLoader__.load({
       );
     }
 
+    /**
+     * 一块从中间升起的面板：新增/编辑人设、新建/编辑团队、查看组装结果都用它。
+     *
+     * 为什么不用平台的 `Modal`：它的宽度不在本运行时的契约里（面板拿到的
+     * 只有 `Button`/`Tag`/`MarkdownText` 的已核实形状），而这三样恰恰需要
+     * 比一句确认宽得多的版面——整段正文、一列成员勾选、一整份组装后的
+     * 提示词。`Confirm` / `Alert` 那种一句话对话框仍然走平台，两者不冲突：
+     * 这里只借用同一层遮罩色和同一套主题 token。
+     *
+     * 三条收尾路径都要有：右上角的关闭、点遮罩、Esc。少一条，用户就会在
+     * 某一次编辑后发现"关不掉"，而那正是弹窗最容易招人烦的地方。
+     */
+    function Sheet({ open, title, hint, width, t, onClose, footer, children }) {
+      React.useEffect(() => {
+        if (open !== true) return undefined;
+        const onKey = (event) => {
+          if (event.key === 'Escape') onClose();
+        };
+        document.addEventListener('keydown', onKey);
+        return () => document.removeEventListener('keydown', onKey);
+      }, [open, onClose]);
+      if (open !== true) return null;
+      return h(
+        'div',
+        { style: { ...L.overlay, zIndex: 60 }, onClick: onClose },
+        h(
+          'div',
+          {
+            style: { ...L.sheet, width: width ?? '760px' },
+            role: 'dialog',
+            'aria-modal': 'true',
+            'aria-label': title,
+            // A click that landed on the window itself — typing, selecting
+            // text, dragging the scrollbar — must not close it.
+            onClick: (event) => event.stopPropagation(),
+          },
+          h(
+            'div',
+            { style: L.sheetHead },
+            h(
+              'div',
+              { style: L.rowMain },
+              h('span', { style: L.rowTitle }, title),
+              hint === undefined || hint === null || hint === '' ? null : h('span', { style: L.hint }, hint),
+            ),
+            h(Btn, {
+              variant: 'toolbar',
+              size: 'sm',
+              icon: h(Icon, { name: 'close', size: 16 }),
+              title: t('close'),
+              'aria-label': t('close'),
+              style: { padding: '0 6px' },
+              onClick: onClose,
+            }),
+          ),
+          h('div', { style: L.sheetBody }, children),
+          footer ?? null,
+        ),
+      );
+    }
+
     /**
      * A v4 UUID, minted by the PANEL rather than the Host.
      *
@@ -1847,41 +1933,21 @@ window.__ModuleLoader__.load({
                 h(Markdown, { text: text ?? '' }),
               );
       /*
-       * The platform's own dialog, like the confirmations next to it — the same
-       * mask, the same close button, the same Escape handling. A hand-rolled
-       * overlay next to a platform dialog is two dialogs wearing one panel.
+       * The same wide window the two editors use, for two reasons.
+       *
+       * Width: this shows the assembled prompt — the thing the model actually
+       * receives — and it was being read through a 560px column, which is
+       * narrower than the editor that produced it. Reading the result should
+       * not be harder than writing it.
+       *
+       * Consistency: the editor that this opens from is a Sheet, so a
+       * different dialog shape one click later would read as two different
+       * products sharing a page.
        */
-      if (primitives !== null && typeof primitives.Modal === 'function') {
-        return h(primitives.Modal, { open: true, onClose, title, closeLabel: t('close'), children: content });
-      }
       return h(
-        'div',
-        { style: L.overlay, onClick: onClose },
-        h(
-          'div',
-          {
-            style: { ...L.dialog, maxWidth: '560px', width: '100%' },
-            // The backdrop closes it; a click that landed on the window itself
-            // — reading, selecting text — must not.
-            onClick: (event) => event.stopPropagation(),
-          },
-          h(
-            'div',
-            { style: L.bar },
-            h('span', { style: L.rowTitle }, title),
-            h('div', { style: L.push }),
-            h(Btn, {
-              variant: 'toolbar',
-              size: 'sm',
-              icon: h(Icon, { name: 'close', size: 16 }),
-              title: t('close'),
-              'aria-label': t('close'),
-              style: { padding: '0 6px' },
-              onClick: onClose,
-            }),
-          ),
-          content,
-        ),
+        Sheet,
+        { open: true, title, width: '980px', t, onClose },
+        content,
       );
     }
 
@@ -1932,7 +1998,7 @@ window.__ModuleLoader__.load({
       );
     }
 
-    function Editor({ draft, t, busy, onPatch, onCommit }) {
+    function Editor({ draft, t, busy, onPatch, onCommit, 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 ?? '';
@@ -1993,7 +2059,7 @@ window.__ModuleLoader__.load({
                * exactly one mode and no state to remember.
                */
               h('textarea', {
-                style: L.textarea,
+                style: tall === true ? { ...L.textarea, minHeight: '44vh' } : L.textarea,
                 value: text,
                 disabled: busy,
                 placeholder: t('bodyPlaceholder'),
@@ -2627,27 +2693,48 @@ window.__ModuleLoader__.load({
       }
       const problem =
         team.problem === null || team.problem === undefined ? null : h('span', { style: L.error }, team.problem);
-      if (draft !== null) {
+      /*
+       * The team editor is a window over the list, the same shape as the
+       * persona editor. It used to replace the list outright: opening one team
+       * hid every other team and the count above them, so the answer to
+       * "is that the one I already have?" was behind the dialog being edited.
+       */
+      const editor =
+        draft === null
+          ? null
+          : h(
+              Sheet,
+              {
+                open: true,
+                title:
+                  draft.name === undefined || draft.name === ''
+                    ? t('teamNew')
+                    : `${t('teamEdit')} · ${draft.name}`,
+                width: '860px',
+                t,
+                onClose: onCancelDraft,
+              },
+              h(TeamDraftCard, {
+                draft,
+                t,
+                busy,
+                rows: team.rows,
+                groups: team.groups,
+                onPatch,
+                onSave: onSaveDraft,
+                onCancel: onCancelDraft,
+                problem: fieldProblem,
+              }),
+            );
+      if (team.teams.length === 0) {
         return h(
           'div',
           { style: L.list },
           problem,
-          h(TeamDraftCard, {
-            draft,
-            t,
-            busy,
-            rows: team.rows,
-            groups: team.groups,
-            onPatch,
-            onSave: onSaveDraft,
-            onCancel: onCancelDraft,
-            problem: fieldProblem,
-          }),
+          h('div', { style: L.card }, h('span', { style: L.hint }, t('teamEmpty'))),
+          editor,
         );
       }
-      if (team.teams.length === 0) {
-        return h('div', { style: L.list }, problem, h('div', { style: L.card }, h('span', { style: L.hint }, t('teamEmpty'))));
-      }
       return h(
         'div',
         { style: L.list },
@@ -2742,6 +2829,7 @@ window.__ModuleLoader__.load({
             h(TeamPreview, { preview: entry.preview, t }),
           );
         }),
+        editor,
       );
     }
 
@@ -3548,6 +3636,7 @@ window.__ModuleLoader__.load({
         onDownloadTemplate,
         onPatchDraft,
         onCommit,
+        onCloseDraft,
         page,
         pageSize,
         onPage,
@@ -3669,45 +3758,53 @@ window.__ModuleLoader__.load({
             groupFolded(group.key)
               ? null
               : group.rows.map((item) =>
-                  h(
-                    React.Fragment,
-                    { key: item.id },
-                    h(WifeRow, {
-                      item,
-                      t,
-                      open: openId === item.id,
-                      busy,
-                      isDefault: data !== null && data.defaultId === item.id,
-                      broken: brokenById === undefined ? null : (brokenById[item.id] ?? null),
-                      selected: batches.includes(item.id),
-                      batchMode,
-                      onToggle: () => onOpenRow(item),
-                      onSelect: () => onSelect(item.id),
-                      onPreview: () => onPreviewOne(item),
-                      onExport: () => onExportOne(item.id),
-                      onHide: () => onHideOne(item),
-                      onDefault: (next) => onSetDefault(item, next),
-                      dragging,
-                      dropTarget,
-                      reorder: reorderMode === true,
-                      onDragStart,
-                      onDragOver,
-                      onDrop,
-                      onDragEnd,
-                    }),
-                    openId === item.id && draft !== null && draft.id === item.id
-                      ? h(Editor, { draft, t, busy, onPatch: onPatchDraft, onCommit })
-                      : null,
-                  ),
+                  h(WifeRow, {
+                    key: item.id,
+                    item,
+                    t,
+                    open: openId === item.id,
+                    busy,
+                    isDefault: data !== null && data.defaultId === item.id,
+                    broken: brokenById === undefined ? null : (brokenById[item.id] ?? null),
+                    selected: batches.includes(item.id),
+                    batchMode,
+                    onToggle: () => onOpenRow(item),
+                    onSelect: () => onSelect(item.id),
+                    onPreview: () => onPreviewOne(item),
+                    onExport: () => onExportOne(item.id),
+                    onHide: () => onHideOne(item),
+                    onDefault: (next) => onSetDefault(item, next),
+                    dragging,
+                    dropTarget,
+                    reorder: reorderMode === true,
+                    onDragStart,
+                    onDragOver,
+                    onDrop,
+                    onDragEnd,
+                  }),
                 ),
             ),
           ),
-        openId === NEW && draft !== null
+        /*
+         * The editor is a window now, not a row that grew.
+         *
+         * A row sits inside the scrolling list, so opening one pushed everything
+         * below it down, and the body was read through a window four rows tall.
+         * One window, sized for the work, opened over the list: the roster stays
+         * where it was, and closing it cannot leave a half-open row behind.
+         */
+        draft !== null && openId !== null
           ? h(
-              'div',
-              { style: L.list },
-              h('div', { style: { ...L.item, ...L.skeletonRow } }, h('span', { style: L.name }, t('add'))),
-              h(Editor, { draft, t, busy, onPatch: onPatchDraft, onCommit }),
+              Sheet,
+              {
+                open: true,
+                // A new persona has no name yet; the edit draft names itself.
+                title: draft.mode === 'new' ? t('personaNew') : `${t('personaEdit')} · ${draft.name || draft.id}`,
+                width: '820px',
+                t,
+                onClose: onCloseDraft,
+              },
+              h(Editor, { draft, t, busy, onPatch: onPatchDraft, onCommit, tall: true }),
             )
           : null,
         pageCount > 1
@@ -5473,6 +5570,8 @@ window.__ModuleLoader__.load({
               onDownloadTemplate: downloadTemplate,
               onPatchDraft: patchDraft,
               onCommit: commit,
+              // Closing the editor window: commit what was typed, then drop the draft.
+              onCloseDraft: closeRow,
               onOpenSkeleton: openSkeleton,
               skeletonDraft,
               onPatchSkeleton: patchSkeletonDraft,

package/http-route.js

@@ -21,6 +21,69 @@
  * 启动这个独立 fiber。它有意待在预设注册之外：万一 webserver 缺席，丢的是
  * 面板，而不是人设。
  */
+/**
+ * 面板路由。是 `prefix`，所以子路径也能匹配。
+ *
+ * 提到模块级是为了让重试的告警文案和错误识别都能引用同一个字符串 —— 用户
+ * 在日志里看到的路径，必须和代码里查找的那条一字不差。
+ */
+const ROUTE_PATH = "/waifu-agents/api";
+
+/**
+ * 注册被占用时的重试间隔（毫秒）。
+ *
+ * ## 为什么要重试
+ *
+ * `webServer.register` 对重复 path **直接抛错**，从不 upsert。热重载时新实例
+ * 的 `apply` 常常早于旧实例的 `dispose`，于是新实例第一次注册必然撞上旧的那
+ * 条路由；而 cordis 不会重试一个抛过错的 fiber —— 结果就是新实例**一直没有**
+ * 面板路由，直到下一次重载。用户看到的是「面板整个消失，以为插件坏了」。
+ *
+ * 旧实例真正让出路由通常在几十毫秒内（同一次重载的收尾），所以短间隔的三次
+ * 试探足以覆盖正常重载；试探失败不重试到底，是因为「旧实例什么时候死」不是
+ * 我们能观测的事 —— 无限重试只会把一个已知失败变成后台噪声。
+ *
+ * 间隔总长 **600 ms**，和告警文案是一对：用户从「面板空白」到「看见一句人话」
+ * 最多等这么久，所以文案里不能写「立刻恢复」——那句话说的是恢复怎么最快，但
+ * 读的人会拿它比对刚才那一段空白。宁可把预算压短、把话写实。
+ */
+const RETRY_DELAYS_MS = [120, 200, 280];
+
+/**
+ * 这条错误是不是「path 已经被占了」。
+ *
+ * 只在文案上认，因为宿主没有给出错误码。宽松到 `duplicate` / `already` 两个
+ * 词：认错（把别的错误当占用）的代价是多试三次仍然失败、最后仍会告警；认漏
+ * 的代价是**当场放弃**，那正是这次要修的那个观感问题。所以宁可认宽。
+ */
+function looksOccupied(error) {
+  const text = String(error?.message ?? error ?? "");
+  return /duplicate|already|exists/i.test(text);
+}
+
+/**
+ * 一次注册尝试的结果，只分三态：拿到 disposer、注册了但没有 disposer、
+ * 或者抛了。
+ *
+ * 「注册了但没有 disposer」不能当失败：路由已经进表、面板已经能用，缺的只是
+ * 我们没法主动注销它 —— 当失败去重试反而会撞上自己刚注册的那条。
+ */
+function adoptRegistration(outcome, onDisposer, onFailure) {
+  if (typeof outcome === "function") {
+    onDisposer(outcome);
+    return;
+  }
+  if (outcome !== null && typeof outcome === "object" && typeof outcome.then === "function") {
+    /* 万一宿主将来改成异步注册：接住 reject，别让它变成未处理的 Promise。 */
+    outcome.then(
+      (fn) => onDisposer(typeof fn === "function" ? fn : null),
+      (error) => onFailure(error),
+    );
+    return;
+  }
+  onDisposer(null);
+}
+
 /**
  * @param {object} ctx 插件自己的上下文
  * @param {{ run: (request: object) => Promise<object> }} deps op 分发器
@@ -29,9 +92,6 @@
 export function installHttpRoute(ctx, deps) {
   const { run } = deps;
 
-  /** 面板路由。是 `prefix`，所以子路径也能匹配。 */
-  const ROUTE_PATH = "/waifu-agents/api";
-
   /** 只有回环（loopback）对端可以驱动这条路由。 */
   function isLoopbackPeer(req) {
     const address = req.socket?.remoteAddress ?? "";
@@ -113,13 +173,122 @@ export function installHttpRoute(ctx, deps) {
    * 在上面的预设注册之外：万一 webserver 缺席，丢的是面板，而不是人设。
    */
   ctx.inject(["webServer"], (ctx) => {
+    /*
+     * 一次注册的完整生命周期都在这个闭包里：重试计时器、拿到的 disposer、
+     * 以及「已经注销了」这个事实。三者必须一起管，否则会留下「注销之后又把
+     * 路由注册回来」的悬空计时器。
+     */
     ctx.effect(
-      () =>
-        ctx.webServer.register({
-          kind: "prefix",
-          path: ROUTE_PATH,
-          handler: (req, res) => handleHttp(req, res),
-        }),
+      () => {
+        let disposed = false;
+        /** 当前这次成功注册拿到的注销函数；没有就是 `null`。 */
+        let release = null;
+        /** 尚未触发的重试；`null` 表示没有在等。 */
+        let timer = null;
+
+        const warn = (message) => {
+          try {
+            ctx.logger?.warn?.(message);
+          } catch {
+            /* 日志服务缺席不该让面板路由这条线再抛一次 */
+          }
+        };
+
+        const detach = () => {
+          const fn = release;
+          release = null;
+          if (typeof fn !== "function") return;
+          try {
+            fn();
+          } catch {
+            /* 旧实例可能已经自行注销；重复注销不是本函数要处理的失败 */
+          }
+        };
+
+        /** 放弃注册时的唯一出口：说人话，且只说一次。 */
+        const giveUp = (error, permanent) => {
+          if (permanent) {
+            warn(
+              `面板路由没注册上：另一个 waifu-agents 实例还占着 ${ROUTE_PATH}（热重载时常见）。` +
+                "设置面板可能到下次重载前都打不开——完全退出 DSH 再启动就能恢复；人设、记忆、团队不受影响。",
+            );
+            return;
+          }
+          warn(
+            `面板路由没注册上（${ROUTE_PATH}）：${String(error?.message ?? error)}。` +
+              "设置面板可能打不开；人设、记忆、团队不受影响。",
+          );
+        };
+
+        const attempt = (index) => {
+          timer = null;
+          if (disposed) return;
+          let outcome;
+          try {
+            outcome = ctx.webServer.register({
+              kind: "prefix",
+              path: ROUTE_PATH,
+              handler: (req, res) => handleHttp(req, res),
+            });
+          } catch (error) {
+            const occupied = looksOccupied(error);
+            if (occupied && index < RETRY_DELAYS_MS.length) {
+              timer = setTimeout(() => attempt(index + 1), RETRY_DELAYS_MS[index]);
+              /* 计时器不该把进程留着不退出：重试是背景行为，不是待办工作。 */
+              timer?.unref?.();
+              return;
+            }
+            giveUp(error, occupied);
+            return;
+          }
+          adoptRegistration(
+            outcome,
+            (fn) => {
+              /*
+               * 先把 disposer 交给 `release`，再决定要不要立刻用掉：
+               * `detach()` 自己会把它置空，所以「这里调一次、之后注销又调一次」
+               * 也只会真正归还一次 —— 幂等性由 `detach` 的 `release = null`
+               * 保证，而不是靠这个分支记得提前 return。
+               *
+               * 这条路径只在注册是异步的（`register` 返回 Promise）时才会走到：
+               * resolve 与 dispose 撞在一起，`disposed` 已经是 true。
+               */
+              release = fn;
+              if (disposed) {
+                detach();
+                return;
+              }
+              if (index > 0) {
+                try {
+                  ctx.logger?.debug?.(`waifu-agents: 面板路由在重试 ${index} 次后注册上了`);
+                } catch {
+                  /* 日志服务缺席不影响已经注册上的路由 */
+                }
+              }
+            },
+            (error) => {
+              const occupied = looksOccupied(error);
+              if (occupied && index < RETRY_DELAYS_MS.length) {
+                timer = setTimeout(() => attempt(index + 1), RETRY_DELAYS_MS[index]);
+                timer?.unref?.();
+                return;
+              }
+              giveUp(error, occupied);
+            },
+          );
+        };
+
+        attempt(0);
+
+        return () => {
+          disposed = true;
+          if (timer !== null) {
+            clearTimeout(timer);
+            timer = null;
+          }
+          detach();
+        };
+      },
       "waifu-agents: http route",
     );
   });