@game25011/dsh-notify-toast 0.0.0-stage → 0.4.2

package/lib/native-focus.js

@@ -0,0 +1,350 @@
+/**
+ * dsh-notify-toast — best-effort Windows window raise for the Host half.
+ *
+ * Contract: docs/INTERFACE.md §2.6. The DSH desktop shell runs this plugin in
+ * an Electron-as-Node Host process, so the window belongs to the parent
+ * Electron main process (`process.ppid`). koffi is not a plugin dependency; we
+ * load the native binding that ships inside the installed app:
+ *
+ *   resources/app.asar.unpacked/dsh/node_modules/@koromix/koffi-win32-x64/
+ *     win32_x64/koffi.node
+ *
+ * Nothing here may throw: every entry point catches and falls back to a
+ * boolean. `focusDesktopWindow()` is synchronous (the user32 calls are cheap)
+ * and safe to call from an RPC request.
+ */
+
+import { existsSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { dirname, join } from 'node:path'
+
+/** Native binding locations relative to a resources root (most specific first). */
+const BINDING_RELATIVES = [
+  ['app.asar.unpacked', 'dsh', 'node_modules', '@koromix', 'koffi-win32-x64', 'win32_x64', 'koffi.node'],
+  [
+    'app.asar.unpacked',
+    'dsh',
+    'node_modules',
+    '@deepseek-ai',
+    'dsh-desktop-host',
+    'node_modules',
+    '@koromix',
+    'koffi-win32-x64',
+    'win32_x64',
+    'koffi.node',
+  ],
+]
+
+/** SW_RESTORE — un-minimize without changing the window size. */
+const SW_RESTORE = 9
+/** Virtual key code for ALT; the key tap satisfies SetForegroundWindow's focus rules. */
+const VK_MENU = 0x12
+const KEYEVENTF_KEYUP = 0x0002
+
+/** Cached loaded API, or null when native focus is unavailable. */
+let api = null
+/** Whether loading was attempted (success or failure). Cached to avoid retries. */
+let loadAttempted = false
+/** Last load failure, exposed through nativeFocusInfo() for diagnostics. */
+let loadError = null
+/** Path of the loaded native binding. */
+let bindingPath = null
+
+/**
+ * Candidate resources roots for the running app.
+ * @returns {string[]} existing-looking roots (no I/O besides the env/execPath reads).
+ */
+function resourcesRoots() {
+  const roots = []
+  try {
+    if (typeof process.resourcesPath === 'string' && process.resourcesPath) roots.push(process.resourcesPath)
+  } catch {
+    /* not Electron */
+  }
+  try {
+    roots.push(join(dirname(process.execPath), 'resources'))
+  } catch {
+    /* no execPath */
+  }
+  // A dev/checkout run of the desktop app may keep the unpacked tree here.
+  try {
+    const localAppData = process.env.LOCALAPPDATA
+    if (localAppData) roots.push(join(localAppData, 'Programs', 'DeepSeek Harness', 'resources'))
+  } catch {
+    /* ignore */
+  }
+  return roots
+}
+
+/**
+ * Locate the packaged koffi binding.
+ * @returns {string|null} absolute path or null.
+ */
+function resolveBindingPath() {
+  for (const root of resourcesRoots()) {
+    for (const relative of BINDING_RELATIVES) {
+      try {
+        const candidate = join(root, ...relative)
+        if (existsSync(candidate)) return candidate
+      } catch {
+        /* ignore a malformed candidate */
+      }
+    }
+  }
+  return null
+}
+
+/**
+ * Load koffi and declare the user32/kernel32 functions once.
+ * @returns {object|null} the function table, or null when unavailable.
+ */
+function loadNativeApi() {
+  if (loadAttempted) return api
+  loadAttempted = true
+  if (process.platform !== 'win32') {
+    loadError = 'native focus is only implemented on win32'
+    return null
+  }
+  try {
+    bindingPath = resolveBindingPath()
+    if (!bindingPath) {
+      loadError = 'koffi native binding not found under the app resources'
+      return null
+    }
+    // koffi's package directory is the parent of win32_x64; createRequire only
+    // uses its dirname as a resolution base, so any filename in that dir works.
+    const requireNative = createRequire(join(dirname(bindingPath), 'index.cjs'))
+    const koffi = requireNative(bindingPath)
+    if (!koffi || typeof koffi.load !== 'function' || typeof koffi.proto !== 'function') {
+      loadError = 'koffi module has an unexpected shape'
+      return null
+    }
+    const user32 = koffi.load('user32.dll')
+    const kernel32 = koffi.load('kernel32.dll')
+
+    // koffi 3 requires the callback prototype to be declared up front and the
+    // function signature to reference it as `WNDENUMPROC *`.
+    koffi.proto('bool __stdcall WNDENUMPROC(void *hWnd, intptr_t lParam)')
+    api = {
+      koffi,
+      EnumWindows: user32.func('bool __stdcall EnumWindows(WNDENUMPROC *cb, intptr_t param)'),
+      IsWindowVisible: user32.func('bool __stdcall IsWindowVisible(void *h)'),
+      IsIconic: user32.func('int __stdcall IsIconic(void *h)'),
+      GetWindowTextLengthW: user32.func('int __stdcall GetWindowTextLengthW(void *h)'),
+      GetWindowTextW: user32.func('int __stdcall GetWindowTextW(void *h, _Out_ uint16 *buf, int max)'),
+      GetClassNameW: user32.func('int __stdcall GetClassNameW(void *h, _Out_ uint16 *buf, int max)'),
+      GetWindowThreadProcessId: user32.func('uint32 __stdcall GetWindowThreadProcessId(void *h, _Out_ uint32 *pid)'),
+      ShowWindow: user32.func('bool __stdcall ShowWindow(void *h, int cmd)'),
+      BringWindowToTop: user32.func('bool __stdcall BringWindowToTop(void *h)'),
+      SetForegroundWindow: user32.func('bool __stdcall SetForegroundWindow(void *h)'),
+      GetForegroundWindow: user32.func('void * __stdcall GetForegroundWindow()'),
+      AttachThreadInput: user32.func('bool __stdcall AttachThreadInput(uint32 attach, uint32 attachTo, bool attachFlag)'),
+      keybd_event: user32.func('void __stdcall keybd_event(uint8 vk, uint8 scan, uint32 flags, uintptr_t extra)'),
+      GetCurrentThreadId: kernel32.func('uint32 __stdcall GetCurrentThreadId()'),
+    }
+    loadError = null
+    return api
+  } catch (error) {
+    loadError = error instanceof Error ? error.message : String(error)
+    api = null
+    return null
+  }
+}
+
+/** Read a window's title (empty string when it has none). */
+function windowTitle(functions, handle) {
+  try {
+    const length = functions.GetWindowTextLengthW(handle)
+    if (length <= 0) return ''
+    const buffer = new Uint16Array(length + 1)
+    functions.GetWindowTextW(handle, buffer, length + 1)
+    return Buffer.from(buffer.buffer, 0, (length + 1) * 2)
+      .toString('utf16le')
+      .replace(/\0.*$/s, '')
+  } catch {
+    return ''
+  }
+}
+
+/** Read a window's class name (empty string on failure). */
+function windowClass(functions, handle) {
+  try {
+    const buffer = new Uint16Array(256)
+    const written = functions.GetClassNameW(handle, buffer, 256)
+    if (!written) return ''
+    return Buffer.from(buffer.buffer, 0, written * 2).toString('utf16le').replace(/\0.*$/s, '')
+  } catch {
+    return ''
+  }
+}
+
+/**
+ * Windows that belong to Electron's chrome but are never the app window. A
+ * PID match alone is not enough: the main process also owns visible top-level
+ * windows such as `OleDdeWndClass` / `DDE Server Window`, `MSCTFIME UI` and
+ * `Default IME`, and raising one of those leaves the real window where it was.
+ */
+const NON_APP_CLASSES = new Set(['OleDdeWndClass', 'MSCTFIME UI', 'IME', 'Default IME', 'DDE Server Window'])
+
+/** Window class of the actual Electron browser window. */
+const APP_WINDOW_CLASS = /^Chrome_WidgetWin/i
+
+/**
+ * List candidate main windows with a score; the highest score is tried first.
+ * Score: app title > browser-window class > parent-process PID; non-app window
+ * classes are filtered out entirely.
+ *
+ * @param {object} functions native function table.
+ * @returns {Array<{handle: any, title: string, pid: number, cls: string, score: number}>}
+ */
+function listDesktopWindows(functions) {
+  const ownPid = Number(process.ppid)
+  const found = []
+  try {
+    functions.EnumWindows((handle) => {
+      try {
+        if (!functions.IsWindowVisible(handle)) return true
+        const cls = windowClass(functions, handle)
+        if (NON_APP_CLASSES.has(cls)) return true
+        const title = windowTitle(functions, handle)
+        if (!title) return true
+        const pidBuffer = new Uint32Array(1)
+        functions.GetWindowThreadProcessId(handle, pidBuffer)
+        const pid = pidBuffer[0]
+        const titleMatch = /deepseek/i.test(title)
+        const classMatch = APP_WINDOW_CLASS.test(cls)
+        if (!titleMatch && !classMatch) return true
+        let score = 0
+        if (titleMatch) score += 100
+        if (classMatch) score += 50
+        if (Number.isInteger(ownPid) && ownPid > 0 && pid === ownPid) score += 20
+        found.push({ handle, title, pid, cls, score })
+        return true
+      } catch {
+        return true
+      }
+    }, 0)
+  } catch {
+    /* enumeration failed: return whatever was captured */
+  }
+  found.sort((left, right) => right.score - left.score)
+  return found
+}
+
+/** Window candidates, highest score first (diagnostics/tests). */
+export function listDesktopWindowCandidates() {
+  const functions = loadNativeApi()
+  if (!functions) return []
+  return listDesktopWindows(functions).map((entry) => ({ ...entry, handle: String(entry.handle) }))
+}
+
+/** Attach to the foreground thread, raise the window, then detach. */
+function activateWindow(functions, handle) {
+  const foreground = functions.GetForegroundWindow()
+  let foregroundThread = 0
+  try {
+    if (foreground !== null && foreground !== undefined) {
+      foregroundThread = functions.GetWindowThreadProcessId(foreground, new Uint32Array(1))
+    }
+  } catch {
+    foregroundThread = 0
+  }
+  const ownThread = functions.GetCurrentThreadId()
+  let attached = false
+  try {
+    if (foregroundThread !== 0 && foregroundThread !== ownThread) {
+      attached = Boolean(functions.AttachThreadInput(foregroundThread, ownThread, true))
+    }
+    functions.SetForegroundWindow(handle)
+    functions.BringWindowToTop(handle)
+  } catch {
+    /* best effort */
+  } finally {
+    if (attached) {
+      try {
+        functions.AttachThreadInput(foregroundThread, ownThread, false)
+      } catch {
+        /* best effort */
+      }
+    }
+  }
+}
+
+/**
+ * Whether the native window-raise path can work in this process (win32 + the
+ * bundled koffi binding loads). Never throws; loading is attempted once.
+ *
+ * @returns {boolean} true when `focusDesktopWindow()` can attempt a raise.
+ */
+export function nativeFocusAvailable() {
+  try {
+    return loadNativeApi() !== null
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Best-effort: restore, raise and foreground the DSH desktop window.
+ *
+ * @returns {boolean} true only when the target window ended up foreground.
+ *   Never throws; every failure (non-win32, missing binding, no window, denied
+ *   SetForegroundWindow) returns false so callers can fall back to
+ *   `window.focus()` on the page.
+ */
+export function focusDesktopWindow() {
+  try {
+    const functions = loadNativeApi()
+    if (!functions) return false
+    const candidates = listDesktopWindows(functions)
+    if (candidates.length === 0) return false
+    for (const target of candidates) {
+      const handle = target.handle
+      try {
+        functions.ShowWindow(handle, SW_RESTORE)
+        functions.BringWindowToTop(handle)
+        // A harmless ALT tap: Windows grants foreground rights to processes that
+        // received the last input event, which is what SetForegroundWindow needs.
+        functions.keybd_event(VK_MENU, 0, 0, 0)
+        functions.keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0)
+      } catch {
+        /* still try the activation below */
+      }
+      activateWindow(functions, handle)
+      if (String(functions.GetForegroundWindow()) === String(handle)) return true
+      // One retry: the first activation can lose the race with a just-focused
+      // foreground window (for example the page that received the click).
+      activateWindow(functions, handle)
+      if (String(functions.GetForegroundWindow()) === String(handle)) return true
+    }
+    return false
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Diagnostics for the RPC health/probe output (not part of the client contract).
+ *
+ * @returns {{available: boolean, modulePath: string|null, error: string|null, platform: string}}
+ */
+export function nativeFocusInfo() {
+  try {
+    const available = nativeFocusAvailable()
+    return {
+      available,
+      modulePath: bindingPath,
+      error: available ? null : loadError,
+      platform: process.platform,
+      candidates: available ? listDesktopWindowCandidates() : [],
+    }
+  } catch (error) {
+    return {
+      available: false,
+      modulePath: null,
+      error: error instanceof Error ? error.message : String(error),
+      platform: 'unknown',
+      candidates: [],
+    }
+  }
+}

package/lib/native-toast-helper.cs

@@ -0,0 +1,206 @@
+using System;
+using System.Globalization;
+using System.Net;
+using System.Threading;
+using Windows.Data.Xml.Dom;
+using Windows.Foundation;
+using Windows.UI.Notifications;
+
+public static class DshNativeToast
+{
+    private const int ProgressTickMs = 100;
+    private const int RetentionGraceMs = 5000;
+    private const int RetractionGraceMs = 300;
+    private const int ActivationGraceMs = 750;
+
+    public static void Run(
+        string aumid,
+        string tag,
+        string group,
+        string title,
+        string body,
+        string progressLabel,
+        string sessionId,
+        string notificationId,
+        string callbackUrl,
+        string token,
+        int durationMs)
+    {
+        var xml = BuildXml(title, body, progressLabel);
+        var document = new XmlDocument();
+        document.LoadXml(xml);
+        var toast = new ToastNotification(document);
+        toast.Tag = tag;
+        toast.Group = group;
+
+        var data = new NotificationData();
+        data.SequenceNumber = 1;
+        data.Values["progressValue"] = "1";
+        // Bind the initial data before Show so the first frame has the bound
+        // progress value instead of waiting for the first Update().
+        toast.Data = data;
+        var safeDuration = Math.Max(1000, durationMs);
+        // Expiration is a notification-center retention deadline, not a
+        // promise about the banner animation. Keep it a little beyond the
+        // progress window so the shell can finish its own transition.
+        toast.ExpirationTime = DateTimeOffset.Now.AddMilliseconds(safeDuration + RetentionGraceMs);
+
+        var stop = new ManualResetEventSlim(false);
+        var activationStarted = new ManualResetEventSlim(false);
+        var activationFinished = new ManualResetEventSlim(false);
+
+        if (!string.IsNullOrEmpty(callbackUrl))
+        {
+            var handler = new TypedEventHandler<ToastNotification, object>(delegate
+            {
+                activationStarted.Set();
+                stop.Set();
+                try
+                {
+                    PostActivation(callbackUrl, token, sessionId, notificationId);
+                }
+                finally
+                {
+                    activationFinished.Set();
+                }
+            });
+            AddHandler(toast, "Activated", handler);
+        }
+        AddHandler(toast, "Dismissed", new TypedEventHandler<ToastNotification, ToastDismissedEventArgs>(delegate
+        {
+            stop.Set();
+        }));
+        AddHandler(toast, "Failed", new TypedEventHandler<ToastNotification, ToastFailedEventArgs>(delegate
+        {
+            stop.Set();
+        }));
+
+        var notifier = ToastNotificationManager.CreateToastNotifier(aumid);
+        notifier.Show(toast);
+        Console.Out.WriteLine("submitted");
+        Console.Out.Flush();
+
+        var started = DateTime.UtcNow;
+        uint sequence = 2;
+        int updateFailures = 0;
+        while (!stop.IsSet)
+        {
+            var elapsed = (int)(DateTime.UtcNow - started).TotalMilliseconds;
+            var remaining = Math.Max(0, safeDuration - elapsed);
+            if (remaining <= 0) break;
+            data.SequenceNumber = sequence++;
+            data.Values["progressValue"] = ((double)remaining / safeDuration).ToString("0.###", CultureInfo.InvariantCulture);
+            try
+            {
+                notifier.Update(data, tag, group);
+                updateFailures = 0;
+            }
+            catch
+            {
+                updateFailures++;
+                if (updateFailures >= 3) break;
+            }
+            if (stop.Wait(ProgressTickMs)) break;
+        }
+
+        // ExpirationTime alone does not remove a visible banner on this Windows
+        // build (observed: a 3 s toast remained after the 4 s expiration while
+        // the helper had already exited). Let the bar finish, then hide the
+        // banner after a short grace. Hide() is the only supported way to
+        // retract it; do not call it while an activation callback is in flight.
+        if (!activationStarted.IsSet)
+        {
+            Thread.Sleep(RetractionGraceMs);
+            try { notifier.Hide(toast); } catch { /* best effort */ }
+        }
+
+        // Keep the process alive for notification-center click callbacks until
+        // the notification expires. ExpirationTime still bounds retention.
+        if (!activationStarted.IsSet)
+        {
+            var expiration = toast.ExpirationTime;
+            var remainingRetentionMs = expiration.HasValue
+                ? (expiration.Value - DateTimeOffset.Now).TotalMilliseconds
+                : 0;
+            if (remainingRetentionMs > 0)
+            {
+                var waitMs = (int)Math.Min(remainingRetentionMs, durationMs + RetentionGraceMs + 1000.0);
+                activationStarted.Wait(TimeSpan.FromMilliseconds(Math.Max(0, waitMs)));
+            }
+        }
+        if (activationStarted.IsSet)
+        {
+            activationFinished.Wait(ActivationGraceMs);
+        }
+    }
+
+    private static void AddHandler<TArgs>(ToastNotification toast, string eventName, TypedEventHandler<ToastNotification, TArgs> handler)
+    {
+        try
+        {
+            var eventInfo = typeof(ToastNotification).GetEvent(eventName);
+            if (eventInfo == null) return;
+            eventInfo.GetAddMethod().Invoke(toast, new object[] { handler });
+        }
+        catch
+        {
+            // A missing event is not fatal; the process still exits after its
+            // bounded grace period.
+        }
+    }
+
+    private static string BuildXml(string title, string body, string progressLabel)
+    {
+        var document = new XmlDocument();
+        var toast = document.CreateElement("toast");
+        toast.SetAttribute("duration", "long");
+        var visual = document.CreateElement("visual");
+        var binding = document.CreateElement("binding");
+        binding.SetAttribute("template", "ToastGeneric");
+        var titleNode = document.CreateElement("text");
+        titleNode.InnerText = title ?? "";
+        binding.AppendChild(titleNode);
+        var bodyNode = document.CreateElement("text");
+        bodyNode.InnerText = body ?? "";
+        binding.AppendChild(bodyNode);
+        var progress = document.CreateElement("progress");
+        progress.SetAttribute("value", "{progressValue}");
+        // Keep the native bar only. Windows needs non-empty title/status on a
+        // ToastGeneric progress element; use spaces, and a zero-width override
+        // to hide the automatic percentage text.
+        progress.SetAttribute("title", " ");
+        progress.SetAttribute("status", string.IsNullOrWhiteSpace(progressLabel) ? "Auto close" : progressLabel);
+        progress.SetAttribute("valueStringOverride", "​");
+        binding.AppendChild(progress);
+        visual.AppendChild(binding);
+        toast.AppendChild(visual);
+        var audio = document.CreateElement("audio");
+        audio.SetAttribute("silent", "true");
+        toast.AppendChild(audio);
+        document.AppendChild(toast);
+        return document.GetXml();
+    }
+
+    private static void PostActivation(string callbackUrl, string token, string sessionId, string notificationId)
+    {
+        try
+        {
+            var payload = "{\"token\":\"" + Escape(token) + "\",\"sessionId\":\"" + Escape(sessionId) + "\",\"notificationId\":\"" + Escape(notificationId) + "\"}";
+            using (var client = new WebClient())
+            {
+                client.Proxy = null;
+                client.Headers[HttpRequestHeader.ContentType] = "application/json";
+                client.UploadString(callbackUrl, "POST", payload);
+            }
+        }
+        catch
+        {
+            // Click callback is best-effort; the Host still sees the native toast.
+        }
+    }
+
+    private static string Escape(string value)
+    {
+        return (value ?? "").Replace("\\", "\\\\").Replace("\"", "\\\"");
+    }
+}