@kesike/reminder-dsh 0.0.0-stage → 0.2.1

package/src/modules/taskbar/windows.js

@@ -0,0 +1,80 @@
+import { spawn } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+
+const script = fileURLToPath(new URL('./badge.ps1', import.meta.url))
+// The helper clears the badge on focus; the lifetime only stops a forgotten process from living forever.
+const badgeMinutes = 120
+
+/** Coalesce taskbar badges for the same app; keep one helper process and update its unread count. */
+export function createTaskbarNotifier({ isEnabled, getWindowTitle }, launch = spawn) {
+  let active, disposed = false, count = 0
+
+  function send(state, message) {
+    if (!state.child.stdin.destroyed) state.child.stdin.write(JSON.stringify(message) + '\n', 'utf8')
+  }
+  function stop(state = active) {
+    if (!state || state.stopping) return
+    state.stopping = true
+    send(state, { type: 'stop' })
+    state.killTimer = setTimeout(() => state.child.kill(), 2000)
+  }
+  function start() {
+    const child = launch('pwsh.exe', ['-NoLogo', '-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass',
+      '-File', script], { windowsHide: true, shell: false, stdio: ['pipe', 'ignore', 'pipe'] })
+    const state = { child, subscribers: new Set(), stopping: false }
+    let resolve, reject, stderr = '', error, finished = false
+    state.done = new Promise((yes, no) => { resolve = yes; reject = no })
+    state.done.catch(() => {})
+    const finish = failure => {
+      if (finished) return
+      finished = true
+      clearTimeout(state.timeout)
+      clearTimeout(state.killTimer)
+      if (active === state) { active = undefined; count = 0 }
+      if (failure && !state.stopping && !disposed) reject(failure)
+      else resolve()
+    }
+    child.stderr.setEncoding('utf8')
+    child.stderr.on('data', value => { stderr = (stderr + value).slice(-2048) })
+    child.on('error', failure => finish(failure.code === 'ENOENT'
+      ? new Error('找不到 pwsh.exe，请安装 PowerShell 7 并重启 DSH。') : failure))
+    child.on('close', code => finish(error ?? (code === 0 ? undefined : new Error(`任务栏角标失败：${stderr.trim() || code}`))))
+    child.stdin.on('error', failure => { error = failure; child.kill() })
+    state.timeout = setTimeout(() => { error = new Error('任务栏角标进程超时'); child.kill() }, (badgeMinutes + 1) * 60_000)
+    send(state, { hostPid: process.pid, windowTitle: getWindowTitle(), count, maxMinutes: badgeMinutes })
+    return state
+  }
+  function subscribe(state, signal) {
+    return new Promise((resolve, reject) => {
+      const subscriber = {}
+      state.subscribers.add(subscriber)
+      const abort = () => {
+        state.subscribers.delete(subscriber)
+        resolve()
+        if (!state.subscribers.size) stop(state)
+      }
+      signal?.addEventListener('abort', abort, { once: true })
+      state.done.then(resolve, reject).finally(() => {
+        state.subscribers.delete(subscriber)
+        signal?.removeEventListener('abort', abort)
+      })
+    })
+  }
+  function notify({ signal } = {}) {
+    if (disposed || !isEnabled() || signal?.aborted) return Promise.resolve()
+    if (active?.stopping) return active.done.catch(() => {}).then(() => notify({ signal }))
+    if (active) {
+      count = Math.min(count + 1, 100)
+      send(active, { type: 'set', count })
+    } else {
+      count = 1
+      active = start()
+    }
+    return subscribe(active, signal)
+  }
+  return {
+    notify,
+    stop: () => stop(),
+    dispose() { disposed = true; stop() },
+  }
+}

package/src/reminder.js

@@ -0,0 +1,93 @@
+import { createUserMessage } from '@deepseek-ai/dsh-llm/message'
+
+/**
+ * Read the current title text of one live session.
+ * The title service returns an immutable snapshot, so only its `title` string is used.
+ * Profiles without that bundle, or sessions without an accepted title yet, yield `undefined`.
+ */
+export function sessionTitleOf(ctx, session) {
+  try {
+    const title = ctx.reflect.get('sessionTitle')?.get(session)?.title
+    return typeof title === 'string' && title !== '' ? title : undefined
+  } catch { return undefined }
+}
+
+/** Register live events only: restored history and initially idle agents do not notify. */
+export function attachReminder(ctx, notify, reportError) {
+  const activities = new WeakMap()
+  const closedAgents = new WeakSet()
+  const notifications = new Map()
+  let disposed = false
+  const isMain = session => session.header.origin !== 'subagent'
+    && !(session.header.delegationDepth > 0)
+
+  ctx.on('agent/status', ({ agent, status }) => {
+    const session = agent.session
+    if (disposed || !isMain(session)) return
+    if (status === 'running') {
+      if (!activities.has(session)) activities.set(session, { completed: false, text: '' })
+      return
+    }
+    if (status !== 'idle') return
+    const activity = activities.get(session)
+    activities.delete(session)
+    if (!activity?.completed) return
+    const controller = new AbortController()
+    const pending = notifications.get(agent) ?? new Set()
+    pending.add(controller)
+    notifications.set(agent, pending)
+    // Consume before launching the subprocess so repeated idle events cannot duplicate it.
+    try {
+      Promise.resolve(notify({
+        sessionId: session.id, sessionTitle: sessionTitleOf(ctx, session), completedText: activity.text,
+        route: agent.model?.current(), signal: controller.signal,
+        onReply(text) {
+          if (disposed || closedAgents.has(agent) || agent.session !== session) {
+            throw new Error('原会话已关闭或切换，请回到 DSH 回复。')
+          }
+          return agent.followup(createUserMessage({
+            content: [{ type: 'text', text }], source: { kind: 'user' },
+          }))
+        },
+      })).catch(error => {
+        if (!disposed && !controller.signal.aborted) reportError(error)
+      }).finally(() => {
+        pending.delete(controller)
+        if (!pending.size) notifications.delete(agent)
+      })
+    } catch (error) {
+      pending.delete(controller)
+      if (!pending.size) notifications.delete(agent)
+      reportError(error)
+    }
+  })
+
+  ctx.on('session/event', (session, event) => {
+    if (disposed) return
+    const activity = activities.get(session)
+    if (!activity) return
+    if (event.type === 'turn/start') {
+      activity.completed = false
+      activity.text = ''
+    }
+    if (event.type === 'assistant/message') {
+      const content = event.data.message.content
+      // Keep only the final, uninterrupted user-visible answer; never reasoning/tool payloads.
+      activity.text = event.data.interrupted || content.some(block => block.type === 'tool-call')
+        ? '' : content.filter(block => block.type === 'text').map(block => block.text).join('\n')
+    }
+    if (event.type === 'turn/end') activity.completed = event.data.reason.kind === 'completed'
+  })
+  ctx.on('agent/error', ({ agent }) => activities.delete(agent.session))
+  ctx.on('agent/disposed', ({ agent }) => {
+    activities.delete(agent.session)
+    closedAgents.add(agent)
+    for (const controller of notifications.get(agent) ?? []) controller.abort()
+    notifications.delete(agent)
+  })
+  ctx.effect(() => () => {
+    disposed = true
+    for (const pending of notifications.values()) for (const controller of pending) controller.abort()
+    notifications.clear()
+  })
+}