dsh-plugin-desktop-notify 0.6.2 → 0.6.4

package/README.en.md

@@ -44,6 +44,7 @@ Stored in localStorage under `dsh-plugin-desktop-notify.preferences`:
 | `notifyError` | `true` | Notify when a turn fails |
 | `notifyViewed` | `false` | Also notify for the session you are looking at |
 | `badge` | `true` | Show the badge |
+| `orderAttention` | `true` | seat what needs you below your pins (writes the view's order, never the pin state) |
 | `excludeSubagents` | `true` | Ignore subagent sessions |
 | `titleComplete` / `titlePending` / `titleError` | empty | Custom titles; empty keeps the built-in copy |
 | `maxBodyChars` | `140` | Body length limit |

package/README.md

@@ -16,6 +16,7 @@
 - **等待你操作**——工具审批、提问、执行计划确认
 - **任务失败**——这一轮出错时提示
 - **说清楚怎么结束的**——正常完成、被拦截、输出到上限、被中止，各自一句话，不把中断说成「已完成」
+- **需要你的排在前面**——运行中、待你审批/回答、出错、未读完成的会话，自动排到**手动置顶的下面、其余会话的上面**，处理完自动放回原位
 - **小红点**——应用图标上显示「需要你的会话数」，你看过之后才清零
 - **点击通知**——切到对应会话，而不是只把应用叫到前面
 
@@ -45,6 +46,7 @@ dsh-plugin-desktop-notify
 | `notifyViewed` | `false` | 正在看的会话也通知（默认跳过） |
 | `badge` | `true` | 显示小红点 |
 | `excludeSubagents` | `true` | 忽略子智能体会话 |
+| `orderAttention` | `true` | 把需要你处理的会话排到手动置顶下面第一条（不改置顶状态；关掉后完全不碰排序） |
 | `titleComplete` / `titlePending` / `titleError` | 空 | 自定义标题，空 = 用内置文案 |
 | `maxBodyChars` | `140` | 正文长度上限 |
 
@@ -60,6 +62,7 @@ dsh-plugin-desktop-notify
 __DSH_DESKTOP_NOTIFY__.capabilities()   // 平台、通知权限、小红点、服务可达性
 __DSH_DESKTOP_NOTIFY__.state()          // 小红点、待处理会话、最近一次通知/点击
 __DSH_DESKTOP_NOTIFY__.report()         // 上面全部 + 窗口焦点，便于排查
+__DSH_DESKTOP_NOTIFY__.orderState()     // 当前被排到前面的是哪几条、按什么顺序
 ```
 
 
@@ -72,6 +75,7 @@ __DSH_DESKTOP_NOTIFY__.report()         // 上面全部 + 窗口焦点，便于
 | `POST` | `/desktop-notify/request` | 发一条通知，body：`{"title": "...", "body": "...", "sessionId": "可选"}` |
 | `GET` | `/desktop-notify/pending` | 渲染层取走待显示的通知（脚本不用调） |
 | `GET` | `/desktop-notify/turn?sessionId=...` | 渲染层确认这一轮是怎么结束的（脚本不用调） |
+| `GET`/`POST` | `/desktop-notify/pins` | 渲染层读写「插件自己置顶了哪些会话」（脚本不用调） |
 
 地址写在 `~/.dsh/desktop-notify.endpoint`，所以调用方不用猜端口：
 
@@ -107,6 +111,9 @@ urllib.request.urlopen(request, timeout=3).read()
 ## 已知限制
 
 - 重启或刷新窗口时，已经存在的「未读 / 待审批」只恢复小红点，不再补弹横幅
+- 这个排序是插件接管「手动排序」实现的：插件只写「需要你」那几条的顺序，其余会话仍然按最近更新往后排，
+  所以视觉上和「最近更新」一样，只是多了一条需要你的带状区域。代价是侧栏的排序方式会显示成「手动」，
+  而且你把会话拖动排序后，下一次有会话需要你时会被重排覆盖。不想要就 `orderAttention: false`
 
 - **Windows**：点通知会切到对应会话，但窗口不一定到前台——`AppUserModelID` 和主进程 focus 通道属于桌面端，渲染层插件做不到
 - **通知归属**：系统通知中心里显示为 DeepSeek Harness（用的是渲染层原生通知）

package/lib/client.js

@@ -30,7 +30,7 @@ window.__ModuleLoader__.load({
   factory: (require) => {
     const NS = "dsh-plugin-desktop-notify"
     /** Reported by capabilities(); keep in step with package.json (cross-machine support). */
-    const VERSION = "0.6.2"
+    const VERSION = "0.6.4"
     const PREFERENCES_KEY = `${NS}:preferences`
 
     /** Defaults; override per field with the localStorage JSON described in README. */
@@ -42,6 +42,8 @@ window.__ModuleLoader__.load({
       notifyViewed: false,
       badge: true,
       excludeSubagents: true,
+      // Seat what needs you directly below the manual pins in its group.
+      orderAttention: true,
       // Empty means "use the built-in copy for the active UI language".
       titleComplete: "",
       titlePending: "",
@@ -141,6 +143,9 @@ window.__ModuleLoader__.load({
      */
     const TURN_KIND_PATH = "/desktop-notify/turn"
     const TURN_LOOKUP_TIMEOUT_MS = 800
+    /** The sidebar's flat-list order key, and how long a tier change waits before it is written. */
+    const FLAT_ORDER_KEY = "__flat_session_order__"
+    const ORDER_SETTLE_MS = 600
 
     /** Ask the Host how one turn ended; undefined when it cannot answer in time. */
     function lookupTurnKind(sessionId) {
@@ -310,6 +315,95 @@ window.__ModuleLoader__.load({
       /** sessionId -> ms timestamp when the current turn was first seen running. */
       const turnStartedAt = new Map()
       let lastBadge
+      /**
+       * The sessions that need you, in the order they started needing you.
+       * FIFO on purpose: a new arrival joins the bottom of the tier instead of
+       * displacing whoever was already in it, so a few running turns can never
+       * shuffle the sidebar under the cursor.
+       */
+      let tier = []
+      /** One coalesced write per settled tier, never one per status tick. */
+      let tierTimer
+      /** Whether an order was ever written, so an empty tier can clear it once and then stay quiet. */
+      let hasWrittenOrder = false
+      /** The last order written per account key; an unchanged tier touches nothing. */
+      const lastOrderByKey = new Map()
+
+      /** The sidebar's workspace snapshot, or undefined on a build without the service. */
+      function workspaceSnapshot() {
+        try {
+          return ctx.uiWorkspace?.workspaces?.list?.getSnapshot?.()
+        } catch {
+          return undefined
+        }
+      }
+
+      /** True when two id arrays are identical, so a no-op sync never reorders anything. */
+      function sameOrder(left, right) {
+        if (left.length !== right.length) return false
+        for (let index = 0; index < left.length; index += 1) if (left[index] !== right[index]) return false
+        return true
+      }
+
+      /** Recompute the tier; only a membership change schedules a write. */
+      function updateTier(wanted) {
+        const next = tier.filter((sessionId) => wanted.has(sessionId))
+        for (const sessionId of wanted) if (!next.includes(sessionId)) next.push(sessionId)
+        if (sameOrder(next, tier)) return
+        tier = next
+        scheduleOrderWrite()
+      }
+
+      /** Coalesce a burst of status ticks into one write. */
+      function scheduleOrderWrite() {
+        if (tierTimer !== undefined) return
+        tierTimer = setTimeout(() => {
+          tierTimer = undefined
+          writeOrder()
+        }, ORDER_SETTLE_MS)
+      }
+
+      /**
+       * Seat the tier directly below the manual pins in every group. Only the
+       * tier ids are written, so everything else keeps falling back to recency:
+       * the result reads like the "most recent" sort with a needs-you band.
+       */
+      function writeOrder() {
+        const view = ctx.uiWorkspace?.view
+        if (typeof view?.setSessionOrder !== "function") return
+        const snapshot = workspaceSnapshot()
+        const list = ctx.sessions.list.getSnapshot()
+        if (snapshot === undefined || list?.phase !== "ready") return
+        const archived = new Set(Array.isArray(snapshot.archivedSessionIds) ? snapshot.archivedSessionIds : [])
+        const live = tier.filter((sessionId) => !archived.has(sessionId))
+        const active = preferences.orderAttention && live.length > 0
+        if (!active && !hasWrittenOrder) return
+        const accounted = new Set()
+        const groups = []
+        for (const item of Array.isArray(snapshot.items) ? snapshot.items : []) {
+          const memberIds = Array.isArray(item?.sessionIds) ? item.sessionIds : []
+          for (const sessionId of memberIds) accounted.add(sessionId)
+          groups.push([item?.workspaceId ?? "", memberIds])
+        }
+        const ids = Array.isArray(list.ids) ? list.ids : []
+        const known = (sessionId) => list.byId?.[sessionId] !== undefined
+        groups.push(["", ids.filter((sessionId) => known(sessionId) && !accounted.has(sessionId))])
+        groups.push([FLAT_ORDER_KEY, ids.filter(known)])
+        for (const [key, memberIds] of groups) {
+          const members = new Set(memberIds)
+          const order = active ? live.filter((sessionId) => members.has(sessionId)) : []
+          const signature = order.join("\n")
+          if (lastOrderByKey.get(key) === signature) continue
+          try {
+            view.setSessionOrder(key, order, {})
+            lastOrderByKey.set(key, signature)
+          } catch {
+            /* a view store that refuses the write keeps its own order */
+          }
+        }
+        hasWrittenOrder = active
+      }
+
       /** The last banner attempt and its outcome — Windows has several ways to swallow it. */
       let lastNotify
       /** The last banner click and what it managed to do — Windows/macOS differ here. */
@@ -551,6 +645,8 @@ window.__ModuleLoader__.load({
         const statuses = ctx.uiSession.sessionStatus.getSnapshot()
         const summaries = ctx.sessions.list.getSnapshot().byId ?? {}
         const seen = new Set()
+        /** Sessions that should sit at the top of their group. */
+        const wanted = new Set()
 
         for (const [sessionId, status] of statuses) {
           const summary = summaries[sessionId]
@@ -592,8 +688,8 @@ window.__ModuleLoader__.load({
             turnStartedAt.delete(sessionId)
             const duration = started === undefined ? "" : durationText(Date.now() - started, languageOf())
             // Watching it finish is only worth a banner when the user opted in.
-            const wanted = preferences.notifyComplete && (looking ? preferences.notifyViewed : true)
-            if (wanted) deliverCompletion(sessionId, table, name, duration)
+            const shouldNotify = preferences.notifyComplete && (looking ? preferences.notifyViewed : true)
+            if (shouldNotify) deliverCompletion(sessionId, table, name, duration)
           }
 
           if (looking) {
@@ -620,6 +716,13 @@ window.__ModuleLoader__.load({
             })
           }
 
+          // The tier follows the same facts the banner and badge use, plus a
+          // running turn: anything that would make you look belongs on top.
+          const current = attention.get(sessionId) ?? {}
+          if (!looking && (running || current.completed === true || current.pendingKind !== undefined || current.error !== undefined)) {
+            wanted.add(sessionId)
+          }
+
           previous.set(sessionId, { running, completed, pendingKind })
         }
 
@@ -628,6 +731,7 @@ window.__ModuleLoader__.load({
           previous.delete(sessionId)
           turnStartedAt.delete(sessionId)
         }
+        updateTier(wanted)
         applyBadge()
       }
 
@@ -762,10 +866,25 @@ window.__ModuleLoader__.load({
             badge: lastBadge ?? 0,
             attention: [...attention.entries()].map(([sessionId, entry]) => ({ sessionId, ...entry })),
             tracked: [...previous.keys()],
+            order: [...tier],
             lastNotify: lastNotify ?? null,
             lastClick: lastClick ?? null,
           }
         },
+        /** Which sessions the plugin seats under the pins, and in what order. */
+        orderState() {
+          return {
+            enabled: preferences.orderAttention,
+            tier: [...tier],
+            written: Object.fromEntries([...lastOrderByKey].map(([key, value]) => [key, value === "" ? 0 : value.split("\n").length])),
+          }
+        },
+        /** Drop the whole tier; the next settle clears it from the sidebar. */
+        clearOrder() {
+          tier = []
+          scheduleOrderWrite()
+          return this.orderState()
+        },
         simulateComplete(sessionId = "desktop-notify-simulation") {
           const table = copy(languageOf())
           setAttention(sessionId, { completed: true })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-desktop-notify",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "type": "module",
   "description": "Desktop notifications and a Dock/taskbar badge for DeepSeek Harness: a finished turn, a pending approval or question, and a failure, with click-through back to the session",
   "license": "MIT",
@@ -58,5 +58,8 @@
   },
   "scripts": {
     "test": "node test/client.test.mjs && node test/host.test.mjs /tmp/dsh-notify-host-test.log"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }