dsh-workspace-plus 0.6.1 → 0.7.1

package/lib/notice/index.js

@@ -31,11 +31,36 @@
  * is the one place the plugin leaves the host process:
  *
  *   1. the toast carries a `dsh-notice:open?s=<session>` protocol activation;
- *   2. the plugin registers that protocol under HKCU, pointing at a small
- *      PowerShell launcher that calls this plugin's own loopback route;
- *   3. the route records the session, brings the desktop window forward, and
- *      the browser half — which polls the plugin's route — selects that
- *      conversation through the Harness's own `uiWorkspace.openSession`.
+ *   2. the plugin registers that protocol under HKCU, pointing at the best
+ *      click launcher this machine can actually run. `launcher.js` owns that
+ *      choice, in this order:
+ *        - `helper` — a small compiled C# window (`click-host.cs`) that calls
+ *          this plugin's own loopback route and then restores and focuses the
+ *          Harness window itself, in the same process. It exists because every
+ *          PowerShell path below is worse at exactly that job: a console
+ *          flashes on each click, the foreground lock routinely refuses a focus
+ *          request from a freshly started child process, and a window resting in
+ *          the tray is not reachable from a script at all. The helper is also
+ *          cheap — no interpreter startup, no second Electron instance per
+ *          click, which is what the old `dsh://open` route cost.
+ *        - `windowless-powershell` — `powershell.exe` started such that no
+ *          console window can appear, for a machine that cannot build the
+ *          helper.
+ *        - `powershell` — the plain `-WindowStyle Hidden` invocation of
+ *          `click.ps1`, the last resort that still needs a working PowerShell.
+ *   3. the route records the session and answers 200. With either PowerShell
+ *      launcher it then still asks the desktop application (`dsh://open`) to
+ *      bring its window forward; with the helper it does NOT, because the
+ *      helper has already done it — and spawning a second Electron instance per
+ *      click is the slow, unreliable path this replaced. The browser half —
+ *      which polls the plugin's route — then selects that conversation through
+ *      the Harness's own `uiWorkspace.openSession`.
+ *
+ * When `focusOnClick` is false the click only selects the conversation and never
+ * raises the window: the launcher is selected with `focus: false` (so the helper
+ * is registered without its restore-and-focus step) and the route below skips the
+ * `dsh://open` fallback. A click then changes what the window shows, not whether
+ * it is on screen.
  *
  * Step 3 is why the browser half exists at all: the Host cannot select a
  * conversation in a page's UI, so it publishes the intent and the page applies
@@ -58,6 +83,7 @@ import {
   isInScope,
   openUrl,
 } from './format.js'
+import { selectLauncher } from './launcher.js'
 import {
   KIND_LABELS,
   KINDS,
@@ -72,8 +98,6 @@ import { ToastDaemon, toastTag } from './toast.js'
 import {
   focusDesktopWindow,
   isSupported,
-  powershellPath,
-  protocolCommand,
   readProtocolCommand,
   registerProtocol,
   unregisterProtocol,
@@ -94,7 +118,15 @@ export const PENDING_PATH = '/dsh-notice/api/pending'
 /** Directory holding this plugin's shipped assets. */
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url))
 
-/** PowerShell launcher the protocol registration points at. */
+/**
+ * PowerShell launcher the protocol registration falls back to.
+ *
+ * `selectLauncher` builds the two PowerShell command lines around this script
+ * and the host never invokes it; it stays exported because the path is part of
+ * the plugin's shipped surface (and of the dsh-notice contract this sub-feature
+ * was ported from), and because a registration written by an older version still
+ * points here until it is retired.
+ */
 export const CLICK_SCRIPT = join(MODULE_DIR, 'click.ps1')
 
 /** Largest accepted settings request body. */
@@ -263,6 +295,18 @@ export function apply(ctx, config) {
   /** Scheme that command was written under, so a change can retire it. */
   let registeredScheme = null
 
+  /**
+   * Which click launcher the registered command belongs to, or null.
+   *
+   * The command line alone cannot answer this, and the answer matters to the
+   * open route: the compiled helper focuses the window itself after answering,
+   * while the PowerShell paths leave that to the host. Kept beside the command
+   * so every place that clears one clears all three — a stale launcher kind would
+   * make the host skip (or repeat) the focus step for a command that no longer
+   * exists.
+   */
+  let registeredLauncher = null
+
   /** The last conversation the plugin announced, used by the test action. */
   let lastSessionId = null
 
@@ -560,6 +604,15 @@ export function apply(ctx, config) {
   /**
    * One synchronous-ish pass over the registry. Callers use `syncProtocol`.
    *
+   * The click command is not built here any more. Which launcher works is a
+   * property of the machine (is there a C# compiler for the helper, is there a
+   * PowerShell, does the window need restoring) rather than of the settings, so
+   * `selectLauncher` owns that decision and the host only compares and writes the
+   * command line it returns. It is asked on every pass — that is what keeps the
+   * registration idempotent, since the command compared is always the freshly
+   * selected one — and it caches the helper it builds, so only the first pass of
+   * a host process ever pays the couple of seconds that build costs.
+   *
    * @returns the outcome for the settings page.
    */
   const syncProtocolNow = async () => {
@@ -573,6 +626,7 @@ export function apply(ctx, config) {
       const previousCommand = registeredCommand
       registeredScheme = null
       registeredCommand = null
+      registeredLauncher = null
       const stored = await readProtocolCommand(previous)
       if (previousCommand === null || stored === previousCommand) await unregisterProtocol(previous)
     }
@@ -584,6 +638,7 @@ export function apply(ctx, config) {
         await unregisterProtocol(scheme)
         registeredCommand = null
         registeredScheme = null
+        registeredLauncher = null
       }
       return { ok: true, message: '已关闭协议注册：点击通知只会把 Harness 窗口切到前台' }
     }
@@ -591,22 +646,41 @@ export function apply(ctx, config) {
     if (port === null) return { ok: false, message: '尚未获知 Harness 监听端口，稍后重试' }
     await retireOldScheme()
 
-    const command = protocolCommand({
-      powershell: powershellPath(),
-      script: CLICK_SCRIPT,
-      scheme,
-      port,
-      token,
-    })
+    // `focusOnClick` is passed into the selection rather than applied later: the
+    // helper embeds its own focus step, so the two choices produce different
+    // command lines and flipping the switch correctly causes one re-registration.
+    let selected
+    try {
+      selected = await selectLauncher({ scheme, port, token, focus: settings.focusOnClick === true })
+    } catch (error) {
+      // By contract this never happens, and by policy it must not matter: a
+      // launcher that cannot be prepared means clicks degrade to `dsh://open`
+      // (see `activationFor`), which is exactly the failure this should produce.
+      // Plugin load is not allowed to fail over a notification detail.
+      const message = String((error && error.message) || error)
+      ctx.logger?.warn?.(`[dsh-workspace-plus/notice] 选择点击启动器失败：${message}`)
+      return { ok: false, message: `无法准备点击启动器：${message}` }
+    }
+    const command = typeof selected?.command === 'string' ? selected.command : ''
+    if (selected?.ok !== true || command === '') {
+      // An old registration under this same scheme is deliberately left alone:
+      // a stale key still swallows a click quietly, whereas a deleted one makes
+      // Windows pop "how do you want to open this link" on every click.
+      return { ok: false, message: String(selected?.message ?? '没有可用的点击启动器') }
+    }
+    const launcher = typeof selected.kind === 'string' ? selected.kind : null
+
     const stored = await readProtocolCommand(scheme)
     if (stored === command) {
       registeredCommand = command
       registeredScheme = scheme
+      registeredLauncher = launcher
       return { ok: true, message: `${scheme}: 已注册` }
     }
     const result = await registerProtocol({ scheme, command })
     registeredCommand = result.ok ? command : null
     registeredScheme = result.ok ? scheme : null
+    registeredLauncher = result.ok ? launcher : null
     return result
   }
 
@@ -626,10 +700,14 @@ export function apply(ctx, config) {
    * notification would then reach a route that rejects it.
    *
    * Every run is serialized behind the previous one. The bookkeeping
-   * (`registeredCommand`/`registeredScheme`) is assigned after `await`s, and the
-   * four call sites genuinely race — a page reporting its origin while the user
-   * flips a switch would otherwise be able to leave the variables describing a
-   * registry state that no longer exists, or an orphaned key behind.
+   * (`registeredCommand`/`registeredScheme`/`registeredLauncher`) is assigned
+   * after `await`s, and the four call sites genuinely race — a page reporting its
+   * origin while the user flips a switch would otherwise be able to leave the
+   * variables describing a registry state that no longer exists, or an orphaned
+   * key behind. The serialization has a second, visible effect: the first pass
+   * may spend a couple of seconds building the click helper, and every later
+   * caller waits for that pass instead of starting a competing build, while the
+   * plugin itself keeps loading (this chain is never awaited at load).
    *
    * @returns the outcome for the settings page.
    */
@@ -754,6 +832,12 @@ export function apply(ctx, config) {
         scheme: settings.scheme,
         registeredScheme,
         registered: registeredCommand !== null,
+        // Which click path the registered command runs, so the settings page can
+        // say what a click will actually do on this machine: the compiled helper
+        // restores and focuses the window itself, the PowerShell fallbacks need
+        // the host to ask the desktop application to. Null whenever nothing of
+        // ours is registered.
+        launcher: registeredLauncher,
         port: listenPort(),
       },
       platformSupported: isSupported(),
@@ -820,6 +904,7 @@ export function apply(ctx, config) {
             const result = await unregisterProtocol(current().scheme)
             registeredCommand = null
             registeredScheme = null
+            registeredLauncher = null
             sendJson(res, 200, { ...snapshot(), ok: true, message: result.message })
             return
           }
@@ -888,7 +973,15 @@ export function apply(ctx, config) {
         const settings = current()
         res.writeHead(200, { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' })
         res.end('ok')
-        if (settings.focusOnClick === true) void focusDesktopWindow().catch(() => {})
+        // The compiled helper focuses the window itself, immediately after this
+        // route has answered: it restores a minimized or tray-hidden window and
+        // takes the foreground from the same process that just made the request.
+        // Asking the desktop application to focus as well would spawn a second
+        // Electron instance on every click — slow, and the `dsh://open`
+        // activation is unreliable exactly when the first instance is busy. The
+        // PowerShell launchers cannot do any of that from their own process, so
+        // they keep the fallback.
+        if (settings.focusOnClick === true && registeredLauncher !== 'helper') void focusDesktopWindow().catch(() => {})
       } catch (error) {
         ctx.logger?.warn?.(`[dsh-workspace-plus/notice] ${String((error && error.message) || error)}`)
         res.writeHead(500, { 'content-type': 'text/plain; charset=utf-8' })
@@ -925,6 +1018,7 @@ export function apply(ctx, config) {
     const scheme = registeredScheme
     registeredCommand = null
     registeredScheme = null
+    registeredLauncher = null
     if (owned === null || scheme === null) return
     void readProtocolCommand(scheme)
       .then((stored) => {