dsh-lite-pet 0.2.1 → 0.2.3

package/index.js

@@ -33,6 +33,9 @@ const ENABLED_ROUTE = '/api/dsh-lite-pet/enabled'
 const PUSH_INTERVAL_MS = 250
 const BUBBLE_TEXT_LIMIT = 120
 const BALANCE_VISIBLE_MS = 9000
+// Backstop for the "completed" bubble. Clicking the pet clears it immediately; this only
+// stops a forgotten message from sitting there for the rest of the session.
+const DONE_VISIBLE_MS = 12 * 60_000
 const RESTART_DELAY_MS = 4000
 const MAX_RESTARTS = 3
 
@@ -313,7 +316,22 @@ function handlePetLine(ctx, runtime, profile, message) {
     return
   }
   if (message?.t === 'open') {
-    openHarness(ctx, runtime)
+    // Clicking the pet is the user acknowledging the result: the completed bubble has
+    // done its job once they have gone looking. Clearing it here also means a later
+    // "done" from another session is the only thing that can put it back, instead of
+    // a twelve-minute-old message reappearing after every click.
+    runtime.doneText = null
+    runtime.doneAt = 0
+    runtime.lastSent = ''
+    // The pet tries first: it can show or restore the window on its own, and only if it
+    // finds the window hidden does it need the shell reached from this process.
+    void openHarness(ctx, runtime)
+    pushState(ctx, runtime, profile)
+    return
+  }
+  if (message?.t === 'hidden') {
+    // Sent after the pet's own attempt failed, so the cheap routes are already exhausted.
+    void reopenHidden(ctx, runtime)
     return
   }
   if (message?.t === 'balance') {
@@ -495,28 +513,42 @@ function pushState(ctx, runtime, profile) {
   const now = Date.now()
   let mode = 'idle'
   let text
-  let touched = -1
   let waitingAgent = null
   let runningAgent = null
+  // Each direction compares against its own timestamp. Sharing one accumulator made the
+  // running candidate inherit the waiting candidate's timestamp, so with no session
+  // waiting the accumulator stayed at its initial value and every running session passed
+  // the comparison — the last one inserted into the map won, whatever its actual activity.
+  // The bubble then narrated a session the user had already left.
+  let waitingTouched = -1
+  let runningTouched = -1
   for (const [agentId, state] of runtime.agents) {
     if (now - state.touched > 60_000) continue
-    if (state.waiting > 0 && (waitingAgent === null || state.touched > touched)) {
+    if (state.waiting > 0 && state.touched > waitingTouched) {
       waitingAgent = agentId
-      touched = state.touched
+      waitingTouched = state.touched
     }
-    if (state.running && (runningAgent === null || state.touched > touched)) {
+    if (state.running && state.touched > runningTouched) {
       runningAgent = agentId
+      runningTouched = state.touched
     }
   }
+  // Priority, highest first: waiting (yellow) > done (green) > working (plain).
+  //
+  // The green completion state outranks working on purpose. A session that just finished is
+  // the thing the user is waiting to hear about, and it would otherwise be drowned out by any
+  // other session that happens to be busy — which is the common case with several chats open.
+  // It stays below waiting because a pending decision blocks that session and demands
+  // attention.
   if (waitingAgent !== null) {
     mode = 'waiting'
     text = bubbleText(runtime.agents.get(waitingAgent).text) || '需要你确认一下'
+  } else if (runtime.doneText !== null && now - runtime.doneAt < DONE_VISIBLE_MS) {
+    mode = 'done'
+    text = runtime.doneText
   } else if (runningAgent !== null) {
     mode = 'working'
     text = bubbleText(runtime.agents.get(runningAgent).text) || '正在工作…'
-  } else if (runtime.doneText !== null && now - runtime.doneAt < 12 * 60_000) {
-    mode = 'done'
-    text = runtime.doneText
   }
 
   const payload = JSON.stringify({ t: 'state', mode, text })
@@ -579,56 +611,137 @@ async function sendBalance(ctx, runtime, profile) {
   sendPet(runtime, { t: 'state', mode: 'balance', text, level })
 }
 
-// ——— open the Harness window ——————————————————————————————————————————
-
-let protocolChecked
-function desktopProtocolRegistered() {
-  if (protocolChecked !== undefined) return protocolChecked
-  try {
-    const probe = spawn('reg.exe', ['query', 'HKCU\\Software\\Classes\\dsh', '/ve'], { windowsHide: true })
-    let out = ''
-    probe.stdout.setEncoding('utf8')
-    probe.stdout.on('data', (chunk) => {
-      out += chunk
-    })
-    probe.on('close', () => {
-      protocolChecked = out.includes('URL:dsh')
-    })
-    probe.on('error', () => {
-      protocolChecked = false
-    })
-    return true // optimistic for the first click; the probe settles quickly
-  } catch {
-    protocolChecked = false
-    return false
+// ——— reopen the desktop window ————————————————————————————————————————
+
+// Ask the desktop shell to show its window by clicking its own tray icon.
+//
+// This runs in the plugin process, not in the pet, and that is the whole point. The
+// sandbox starts the pet at low integrity; a low-integrity process is blocked by UIPI
+// from reading the taskbar's XAML automation tree, so it sees five empty children with
+// no tray buttons and every attempt from there fails silently. The plugin host runs at
+// medium integrity, where the same query returns all thirty-one elements and the icon
+// is invocable. Measured on this machine, both ways.
+//
+// PowerShell is used as the automation host because it ships with Windows, inherits
+// this process's integrity, and keeps the plugin free of a compiled helper that would
+// have to be built and shipped alongside it.
+const TRAY_CLICK_SCRIPT = `
+Add-Type -AssemblyName UIAutomationClient
+Add-Type -AssemblyName UIAutomationTypes
+$AE = [System.Windows.Automation.AutomationElement]
+$cond = New-Object System.Windows.Automation.PropertyCondition($AE::ClassNameProperty, 'Shell_TrayWnd')
+$bar = $AE::RootElement.FindFirst([System.Windows.Automation.TreeScope]::Children, $cond)
+if (-not $bar) { exit 2 }
+$all = $bar.FindAll([System.Windows.Automation.TreeScope]::Descendants, [System.Windows.Automation.Condition]::TrueCondition)
+foreach ($e in $all) {
+  try { $cls = $e.Current.ClassName } catch { continue }
+  if ($cls -notlike 'SystemTray.*') { continue }
+  try { $nm = $e.Current.Name } catch { continue }
+  if ($nm.Trim() -like 'DeepSeek Harness*') {
+    $inv = $e.GetCurrentPattern([System.Windows.Automation.InvokePattern]::Pattern)
+    $inv.Invoke()
+    exit 0
   }
 }
-
-function openHarness(ctx, runtime) {
-  const url = (() => {
+exit 1
+`
+
+function clickTrayIcon() {
+  return new Promise((resolve) => {
+    const powershell = join(
+      process.env.SystemRoot ?? 'C:\\Windows',
+      'System32',
+      'WindowsPowerShell',
+      'v1.0',
+      'powershell.exe',
+    )
+    if (!existsSync(powershell)) {
+      resolve(false)
+      return
+    }
+    let child
     try {
-      return ctx.get('webApp', false)?.getAdvertisedUrl?.()
+      child = spawn(powershell, ['-NoProfile', '-NonInteractive', '-Command', TRAY_CLICK_SCRIPT], {
+        windowsHide: true,
+        stdio: 'ignore',
+      })
     } catch {
-      return undefined
+      resolve(false)
+      return
+    }
+    let settled = false
+    const finish = (value) => {
+      if (settled) return
+      settled = true
+      resolve(value)
+    }
+    const timer = setTimeout(() => {
+      try {
+        child.kill()
+      } catch {
+        /* already gone */
+      }
+      finish(false)
+    }, 6000)
+    timer.unref?.()
+    child.on('error', () => {
+      clearTimeout(timer)
+      finish(false)
+    })
+    child.on('close', (code) => {
+      clearTimeout(timer)
+      finish(code === 0)
+    })
+  })
+}
+/**
+ * Reopen the desktop window, doing the cheap thing first.
+ *
+ * The pet can handle the common cases itself: it already enumerates the shell's windows, and
+ * IsWindowVisible / IsIconic / WM_SYSCOMMAND are plain Win32 calls that the sandbox's low
+ * integrity does not restrict. So it is told to try first, and the tray click — which costs
+ * a PowerShell process and about 650 ms, because only a medium-integrity process can read
+ * the taskbar's automation tree — happens only when the pet reports that the window is hidden
+ * and out of its reach.
+ *
+ * In steady state, where the window is already visible or merely minimised, nothing here
+ * runs at all.
+ */
+async function openHarness(ctx, runtime) {
+  if (runtime.pet === null) {
+    // No pet to try through: go straight to the shell's own route.
+    if (await clickTrayIcon()) return
+    const url = (() => {
+      try {
+        return ctx.get('webApp', false)?.getAdvertisedUrl?.()
+      } catch {
+        return undefined
+      }
+    })()
+    if (url === undefined || url === null || url === '') return
+    try {
+      const child = spawn('cmd.exe', ['/c', 'start', '', url], { windowsHide: true, detached: true, stdio: 'ignore' })
+      child.unref()
+    } catch (error) {
+      ctx.logger?.warn?.(`[dsh-lite-pet] cannot open the Harness: ${String(error?.message ?? error)}`)
     }
-  })()
-  const registered = desktopProtocolRegistered()
-  // The pet does the window work: it is a native process, so it can call
-  // ShellExecuteEx on dsh://open (measured to be the only invocation that reaches the
-  // running desktop instance — `cmd start` and `rundll32 url.dll` both failed here),
-  // and it can restore a minimised window through WM_SYSCOMMAND/SC_RESTORE.
-  // When the protocol is not registered, fall back to opening the web GUI.
-  if (registered) {
-    sendPet(runtime, { t: 'raise' })
     return
   }
-  if (url === undefined || url === null || url === '') return
-  try {
-    const child = spawn('cmd.exe', ['/c', 'start', '', url], { windowsHide: true, detached: true, stdio: 'ignore' })
-    child.unref()
-  } catch (error) {
-    ctx.logger?.warn?.(`[dsh-lite-pet] cannot open the Harness: ${String(error?.message ?? error)}`)
-  }
+  sendPet(runtime, { t: 'raise' })
+}
+
+/**
+ * Click the tray icon on the pet's behalf.
+ *
+ * The pet sends this after its own attempt showed that the window is hidden, so no
+ * visibility check is repeated here: the point of the message is that the cheap routes are
+ * exhausted.
+ */
+async function reopenHidden(ctx, runtime) {
+  if (await clickTrayIcon()) return
+  // The shell route is the last thing left; it does not reopen a hidden window on this
+  // machine, but it is harmless and does work in builds whose handler runs synchronously.
+  sendPet(runtime, { t: 'raise' })
 }
 
 // ——— browser routes ————————————————————————————————————————————————————

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-lite-pet",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "轻量系统级桌宠：原生进程逐像素透明渲染，工作正文/等待确认/完成提示与余额查询联动，点击穿透",
   "type": "module",
   "main": "index.js",