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

package/lib/native-toast.js

@@ -0,0 +1,372 @@
+/**
+ * dsh-notify-toast — Host-side Windows native toast manager.
+ *
+ * A small PowerShell/C# helper shows a real Windows toast with a bound
+ * <progress> bar, updates it while the notification is displayed, and posts the click
+ * activation back to a per-Host loopback callback. The Host owns the callback
+ * token and never trusts arbitrary callback URLs from the client.
+ */
+import { spawn } from 'node:child_process'
+import { createServer } from 'node:http'
+import { randomBytes, timingSafeEqual } from 'node:crypto'
+import { basename, join } from 'node:path'
+
+const KINDS = new Set(['question', 'approval', 'complete', 'test'])
+const GROUP = 'dsh-notify-toast'
+const MAX_BODY = 4096
+const SUBMIT_TIMEOUT_MS = 12000
+const WARM_TIMEOUT_MS = 20000
+const MAX_ACTIVE_TOASTS = 8
+const DURATION_MIN_MS = 3000
+const DURATION_MAX_MS = 30000
+
+function clampDuration(value) {
+  const number = Number(value)
+  if (!Number.isFinite(number)) return 8000
+  return Math.max(DURATION_MIN_MS, Math.min(DURATION_MAX_MS, Math.round(number)))
+}
+
+function jsonResponse(res, status, value) {
+  try {
+    const body = Buffer.from(JSON.stringify(value), 'utf8')
+    res.writeHead(status, {
+      'content-type': 'application/json; charset=utf-8',
+      'content-length': String(body.length),
+      'cache-control': 'no-store',
+    })
+    res.end(body)
+  } catch {
+    try { res.destroy() } catch { /* ignore */ }
+  }
+}
+
+function sameToken(provided, expected) {
+  if (typeof provided !== 'string' || provided.length !== expected.length) return false
+  try {
+    return timingSafeEqual(Buffer.from(provided, 'utf8'), Buffer.from(expected, 'utf8'))
+  } catch {
+    return false
+  }
+}
+
+/**
+ * @param {object} options
+ * @param {string} options.scriptPath absolute path to native-toast.ps1
+ * @param {(sessionId: string, notificationId: string) => void} options.onActivate
+ * @param {(message: string, error?: unknown) => void} [options.logWarn]
+ * @param {string} [options.powershellPath]
+ * @param {string} [options.aumid]
+ */
+export function createNativeToastManager(options) {
+  const {
+    scriptPath,
+    onActivate,
+    logWarn = () => {},
+    powershellPath = join(process.env.WINDIR || 'C:\\Windows', 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe'),
+    aumid = 'electron.app.' + basename(process.execPath || 'DeepSeek Harness.exe', '.exe'),
+    spawnProcess = spawn,
+  } = options || {}
+
+  let disposed = false
+  let server = null
+  let pendingServer = null
+  let serverReady = null
+  let callbackUrl = null
+  let warmPromise = null
+  let warmChild = null
+  let serverStartupReject = null
+  const token = randomBytes(32).toString('hex')
+  const active = new Map()
+
+  function readJsonBody(req) {
+    return new Promise((resolve, reject) => {
+      let size = 0
+      const chunks = []
+      req.on('data', (chunk) => {
+        size += chunk.length
+        if (size > MAX_BODY) {
+          reject(new Error('activation body too large'))
+          try { req.destroy() } catch { /* ignore */ }
+          return
+        }
+        chunks.push(chunk)
+      })
+      req.on('end', () => {
+        try {
+          resolve(JSON.parse(Buffer.concat(chunks).toString('utf8')))
+        } catch (error) {
+          reject(error)
+        }
+      })
+      req.on('error', reject)
+    })
+  }
+
+  async function handleActivation(req, res) {
+    if (req.method !== 'POST' || req.url !== '/activate') {
+      jsonResponse(res, 404, { ok: false })
+      return
+    }
+    let body
+    try {
+      body = await readJsonBody(req)
+    } catch {
+      jsonResponse(res, 400, { ok: false })
+      return
+    }
+    if (!body || !sameToken(body.token, token)) {
+      jsonResponse(res, 403, { ok: false })
+      return
+    }
+    const notificationId = typeof body.notificationId === 'string' ? body.notificationId : ''
+    const sessionId = typeof body.sessionId === 'string' ? body.sessionId : ''
+    let record = null
+    for (const candidate of active.values()) {
+      if (candidate.notificationId === notificationId) { record = candidate; break }
+    }
+    if (!record || record.activated) {
+      jsonResponse(res, 200, { ok: true, ignored: true })
+      return
+    }
+    record.activated = true
+    try {
+      onActivate(sessionId, notificationId)
+    } catch (error) {
+      logWarn('native toast activation callback failed', error)
+    }
+    jsonResponse(res, 200, { ok: true })
+  }
+
+  function ensureServer() {
+    if (serverReady) return serverReady
+    serverReady = new Promise((resolve, reject) => {
+      serverStartupReject = reject
+      const candidate = createServer((req, res) => {
+        handleActivation(req, res).catch((error) => {
+          logWarn('native toast activation server error', error)
+          jsonResponse(res, 500, { ok: false })
+        })
+      })
+      pendingServer = candidate
+      candidate.on('error', (error) => {
+        pendingServer = null
+        serverStartupReject = null
+        serverReady = null
+        reject(error)
+      })
+      candidate.listen(0, '127.0.0.1', () => {
+        pendingServer = null
+        if (disposed) {
+          try { candidate.close() } catch { /* ignore */ }
+          serverReady = null
+          serverStartupReject = null
+          reject(new Error('disposed during callback server startup'))
+          return
+        }
+        server = candidate
+        serverStartupReject = null
+        const address = candidate.address()
+        if (!address || typeof address === 'string') {
+          candidate.close()
+          serverReady = null
+          reject(new Error('activation server has no TCP address'))
+          return
+        }
+        callbackUrl = 'http://127.0.0.1:' + address.port + '/activate'
+        resolve()
+      })
+    })
+    return serverReady
+  }
+
+  function killRecord(record) {
+    if (!record) return
+    try { record.child.kill() } catch { /* ignore */ }
+  }
+
+  /**
+   * Compile/load the C# helper without showing a toast. The helper cache is
+   * source-hash keyed; the first real notification should not pay the cold
+   * csc cost. Failures are non-fatal and leave normal delivery/fallback intact.
+   */
+  function warm() {
+    if (disposed) return Promise.resolve(false)
+    if (warmPromise) return warmPromise
+    warmPromise = new Promise((resolve) => {
+      let child
+      try {
+        child = spawnProcess(
+          powershellPath,
+          ['-NoLogo', '-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', scriptPath, '-WarmOnly'],
+          { windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] },
+        )
+      } catch {
+        resolve(false)
+        return
+      }
+      warmChild = child
+      let done = false
+      let output = ''
+      let stderr = ''
+      const finish = (value) => {
+        if (done) return
+        done = true
+        clearTimeout(timer)
+        if (warmChild === child) warmChild = null
+        try { child.kill() } catch { /* ignore */ }
+        resolve(value)
+      }
+      const timer = setTimeout(() => {
+        try { child.kill() } catch { /* ignore */ }
+        finish(false)
+      }, WARM_TIMEOUT_MS)
+      child.stdout.on('data', (chunk) => {
+        output += String(chunk)
+        if (output.includes('warm')) finish(true)
+      })
+      child.stderr.on('data', (chunk) => {
+        stderr += String(chunk)
+      })
+      child.on('error', () => finish(false))
+      child.on('exit', () => {
+        if (output.includes('warm')) finish(true)
+        else {
+          if (stderr) logWarn('native toast prewarm failed: ' + stderr.slice(0, 800))
+          finish(false)
+        }
+      })
+    })
+    return warmPromise
+  }
+
+  async function show(input) {
+    if (disposed) return { ok: false, reason: 'disposed' }
+    const kind = input && typeof input.kind === 'string' ? input.kind : ''
+    if (!KINDS.has(kind)) return { ok: false, reason: 'invalid-kind' }
+    const title = input && typeof input.title === 'string' ? input.title.slice(0, 256) : ''
+    const body = input && typeof input.body === 'string' ? input.body.slice(0, 2048) : ''
+    const sessionId = input && typeof input.sessionId === 'string' ? input.sessionId.slice(0, 256) : ''
+    const durationMs = clampDuration(input && input.durationMs)
+    const progressLabel = input && typeof input.progressLabel === 'string' ? input.progressLabel.slice(0, 32) : ''
+    // Warm in the background; the helper itself still handles a cache miss.
+    void warm()
+    let ready
+    try { ready = await ensureServer() } catch (error) { ready = error }
+    if (ready instanceof Error || disposed) return { ok: false, reason: 'callback-server-unavailable' }
+    if (active.size >= MAX_ACTIVE_TOASTS) {
+      const oldest = active.values().next().value
+      if (oldest) {
+        killRecord(oldest)
+        active.delete(oldest.notificationId)
+      }
+    }
+    const notificationId = kind + '-' + Date.now().toString(36) + '-' + randomBytes(4).toString('hex')
+    const tag = 'dsh-notify-' + kind + '-' + Date.now().toString(36) + '-' + randomBytes(3).toString('hex')
+    const payload = {
+      aumid,
+      tag,
+      group: GROUP,
+      title,
+      body,
+      progressLabel,
+      sessionId,
+      notificationId,
+      callbackUrl,
+      token,
+      durationMs,
+    }
+    let child
+    try {
+      child = spawnProcess(
+        powershellPath,
+        ['-NoLogo', '-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', scriptPath, '-FromStdin'],
+        { windowsHide: true, stdio: ['pipe', 'pipe', 'pipe'] },
+      )
+    } catch (error) {
+      return { ok: false, reason: 'spawn-failed', error: String(error && error.message ? error.message : error) }
+    }
+    const record = { child, notificationId, kind, activated: false }
+    active.set(notificationId, record)
+    child.stdin.on('error', () => {
+      // The helper may exit while the payload is being written.
+    })
+    let stderr = ''
+    child.stderr.on('data', (chunk) => {
+      stderr += String(chunk).slice(0, 1000)
+    })
+    child.on('error', () => {
+      if (active.get(notificationId) === record) active.delete(notificationId)
+    })
+    child.on('exit', () => {
+      if (active.get(notificationId) === record) active.delete(notificationId)
+    })
+    const submitted = await new Promise((resolve) => {
+      let done = false
+      let output = ''
+      const finish = (value) => {
+        if (done) return
+        done = true
+        resolve(value)
+      }
+      const timer = setTimeout(() => {
+        killRecord(record)
+        finish(false)
+      }, SUBMIT_TIMEOUT_MS)
+      child.stdout.on('data', (chunk) => {
+        output += String(chunk)
+        if (output.includes('submitted')) {
+          clearTimeout(timer)
+          finish(true)
+        }
+      })
+      child.on('exit', (code) => {
+        clearTimeout(timer)
+        if (!output.includes('submitted')) {
+          if (stderr) logWarn('native toast helper failed: ' + stderr)
+          finish(false)
+        }
+      })
+      child.on('error', () => {
+        clearTimeout(timer)
+        finish(false)
+      })
+      try {
+        child.stdin.end(Buffer.from(JSON.stringify(payload), 'utf8').toString('base64'))
+      } catch {
+        clearTimeout(timer)
+        finish(false)
+      }
+    })
+    if (!submitted) return { ok: false, reason: 'helper-failed' }
+    return { ok: true, id: notificationId, durationMs }
+  }
+
+  function dispose() {
+    if (disposed) return
+    disposed = true
+    if (warmChild) {
+      try { warmChild.kill() } catch { /* ignore */ }
+      warmChild = null
+    }
+    for (const record of active.values()) killRecord(record)
+    active.clear()
+    if (pendingServer) {
+      const pending = pendingServer
+      pendingServer = null
+      try { pending.close() } catch { /* ignore */ }
+      if (serverStartupReject) {
+        const rejectStartup = serverStartupReject
+        serverStartupReject = null
+        try { rejectStartup(new Error('disposed during callback server startup')) } catch { /* ignore */ }
+      }
+    }
+    if (server) {
+      try { server.close() } catch { /* ignore */ }
+      server = null
+    }
+    serverReady = null
+    callbackUrl = null
+  }
+
+  return { show, warm, ensureServer, dispose }
+}

package/lib/native-toast.ps1

@@ -0,0 +1,72 @@
+param(
+    [switch]$FromStdin,
+    [switch]$WarmOnly
+)
+
+$ErrorActionPreference = 'Stop'
+$source = Join-Path $PSScriptRoot 'native-toast-helper.cs'
+if (-not (Test-Path $source)) { throw "helper source missing: $source" }
+$hash = (Get-FileHash -Algorithm SHA256 -Path $source).Hash.ToLowerInvariant()
+$cacheRoot = Join-Path $env:LOCALAPPDATA 'dsh-notify-toast\native-cache'
+$dll = Join-Path $cacheRoot ($hash + '.dll')
+
+function New-HelperDll {
+    New-Item -ItemType Directory -Path $cacheRoot -Force | Out-Null
+    $csc = Join-Path $env:WINDIR 'Microsoft.NET\Framework64\v4.0.30319\csc.exe'
+    if (-not (Test-Path $csc)) { throw "csc not found: $csc" }
+    $winmdRoot = Join-Path $env:WINDIR 'System32\WinMetadata'
+    $refs = @(
+        (Join-Path $winmdRoot 'Windows.Foundation.winmd'),
+        (Join-Path $winmdRoot 'Windows.UI.winmd'),
+        (Join-Path $winmdRoot 'Windows.Data.winmd'),
+        (Join-Path $env:WINDIR 'Microsoft.NET\Framework64\v4.0.30319\System.Runtime.WindowsRuntime.dll'),
+        (Join-Path $env:WINDIR 'Microsoft.NET\Framework64\v4.0.30319\System.Runtime.InteropServices.WindowsRuntime.dll'),
+        (Join-Path $env:WINDIR 'Microsoft.NET\Framework64\v4.0.30319\System.Runtime.dll')
+    )
+    foreach ($ref in $refs) { if (-not (Test-Path $ref)) { throw "reference missing: $ref" } }
+    $temp = $dll + '.tmp-' + [guid]::NewGuid().ToString('N')
+    $cscArgs = @('/nologo', '/target:library', ('/out:' + $temp))
+    foreach ($ref in $refs) { $cscArgs += ('/r:' + $ref) }
+    $cscArgs += $source
+    $cscOutput = & $csc @cscArgs 2>&1 | Out-String
+    if ($LASTEXITCODE -ne 0 -or -not (Test-Path $temp)) {
+        Remove-Item -Force -ErrorAction SilentlyContinue $temp
+        throw ('native-toast helper compilation failed: ' + $cscOutput)
+    }
+    Move-Item -Force -Path $temp -Destination $dll
+    return $dll
+}
+
+if (-not (Test-Path $dll)) { $dll = New-HelperDll }
+try {
+    Add-Type -Path $dll
+} catch {
+    # A torn or stale cache must not block a real notification. Rebuild once.
+    Remove-Item -Force -ErrorAction SilentlyContinue $dll
+    $dll = New-HelperDll
+    Add-Type -Path $dll
+}
+
+if ($WarmOnly) {
+    Write-Output 'warm'
+    exit 0
+}
+
+$payloadBase64 = if ($FromStdin) { [Console]::In.ReadToEnd().Trim() } else { '' }
+if ([string]::IsNullOrWhiteSpace($payloadBase64)) { throw 'native-toast payload is missing' }
+$payloadJson = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($payloadBase64))
+$payload = $payloadJson | ConvertFrom-Json
+
+[DshNativeToast]::Run(
+    [string]$payload.aumid,
+    [string]$payload.tag,
+    [string]$payload.group,
+    [string]$payload.title,
+    [string]$payload.body,
+    [string]$payload.progressLabel,
+    [string]$payload.sessionId,
+    [string]$payload.notificationId,
+    [string]$payload.callbackUrl,
+    [string]$payload.token,
+    [int]$payload.durationMs
+)

package/lib/taskbar-badge-helper.cs

@@ -0,0 +1,126 @@
+using System;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Drawing.Text;
+using System.Runtime.InteropServices;
+
+// Minimal ITaskbarList3 surface. Only SetOverlayIcon is used here, but the
+// vtable order must match the Windows SDK exactly.
+[ComImport, Guid("ea1afb91-9e28-4b86-90e9-9e9f8a5eefaf"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+internal interface ITaskbarList3
+{
+    void HrInit();
+    void AddTab(IntPtr hwnd);
+    void DeleteTab(IntPtr hwnd);
+    void ActivateTab(IntPtr hwnd);
+    void SetActiveAlt(IntPtr hwnd);
+    void MarkFullscreenWindow(IntPtr hwnd, [MarshalAs(UnmanagedType.Bool)] bool fFullscreen);
+    void SetProgressValue(IntPtr hwnd, ulong ullCompleted, ulong ullTotal);
+    void SetProgressState(IntPtr hwnd, int tbpFlags);
+    void RegisterTab(IntPtr hwndTab, IntPtr hwndMDI);
+    void UnregisterTab(IntPtr hwndTab);
+    void SetTabOrder(IntPtr hwndTab, IntPtr hwndInsertBefore);
+    void SetTabActive(IntPtr hwndTab, IntPtr hwndMDI, uint dwReserved);
+    void ThumbBarAddButtons(IntPtr hwnd, uint cButtons, IntPtr pButtons);
+    void ThumbBarUpdateButtons(IntPtr hwnd, uint cButtons, IntPtr pButtons);
+    void ThumbBarSetImageList(IntPtr hwnd, IntPtr himl);
+    void SetOverlayIcon(IntPtr hwnd, IntPtr hIcon, [MarshalAs(UnmanagedType.LPWStr)] string pszDescription);
+    void SetThumbnailTooltip(IntPtr hwnd, [MarshalAs(UnmanagedType.LPWStr)] string pszTip);
+    void SetThumbnailClip(IntPtr hwnd, IntPtr prcClip);
+}
+
+[ComImport, Guid("56FDF344-FD6D-11d0-958A-006097C9A090")]
+internal class CTaskbarList
+{
+}
+
+/// <summary>
+/// One-shot taskbar overlay badge writer. The process owns the HICON only
+/// until it exits; Windows keeps the rendered overlay after that, which keeps
+/// the helper tiny and avoids a long-lived process.
+/// </summary>
+public static class DshTaskbarBadge
+{
+    public static void Set(IntPtr hwnd, int count)
+    {
+        if (hwnd == IntPtr.Zero) return;
+
+        var taskbar = (ITaskbarList3)new CTaskbarList();
+        taskbar.HrInit();
+
+        if (count <= 0)
+        {
+            taskbar.SetOverlayIcon(hwnd, IntPtr.Zero, string.Empty);
+            return;
+        }
+
+        int shown = count > 3 ? 3 : count;
+        bool overflow = count > 3;
+
+        using (var bitmap = new Bitmap(32, 32))
+        using (var graphics = Graphics.FromImage(bitmap))
+        {
+            graphics.SmoothingMode = SmoothingMode.AntiAlias;
+            graphics.TextRenderingHint = TextRenderingHint.AntiAliasGridFit;
+            graphics.Clear(Color.Transparent);
+
+            // 1-3: a graphite count disc with a thin Fluent-style blue rim.
+            // This follows the neutral/accent direction of GitHub Primer's
+            // badge tokens and Fluent UI's filled badge, instead of the harsh
+            // saturated red block. 4+: a small red dot with a white halo, so
+            // the "more than three" state remains an unread indicator without
+            // asking Windows to render a two-digit number in 16 px.
+            int size = overflow ? 16 : 30;
+            int offset = (32 - size) / 2;
+            Color fillColor = overflow
+                ? Color.FromArgb(255, 196, 49, 75)   // #C4314B, muted GitHub danger
+                : Color.FromArgb(245, 31, 35, 40);   // #1F2328, Primer neutral emphasis
+            using (var fill = new SolidBrush(fillColor))
+            {
+                graphics.FillEllipse(fill, offset, offset, size, size);
+            }
+
+            if (overflow)
+            {
+                using (var halo = new Pen(Color.FromArgb(235, 255, 255, 255), 2f))
+                {
+                    graphics.DrawEllipse(halo, offset, offset, size, size);
+                }
+            }
+            else
+            {
+                // Brand-blue rim: recognizable without the urgency of red.
+                using (var rim = new Pen(Color.FromArgb(255, 47, 129, 247), 2f))
+                {
+                    graphics.DrawEllipse(rim, 1, 1, 30, 30);
+                }
+                // Segoe UI Black + a 20 px glyph. Center the actual glyph path,
+                // not DrawString's padded layout box: this keeps "1", "2" and
+                // "3" optically centered and maximises their footprint in the
+                // 30 px disc after Windows scales it to the 16 px overlay.
+                using (var font = new Font("Segoe UI Black", 20f, FontStyle.Regular, GraphicsUnit.Pixel))
+                using (var textBrush = new SolidBrush(Color.White))
+                using (var format = new StringFormat(StringFormat.GenericTypographic))
+                using (var path = new GraphicsPath())
+                {
+                    path.AddString(shown.ToString(), font.FontFamily, (int)font.Style, font.Size, PointF.Empty, format);
+                    RectangleF bounds = path.GetBounds();
+                    float dx = (32f - bounds.Width) / 2f - bounds.X;
+                    float dy = (32f - bounds.Height) / 2f - bounds.Y;
+                    using (var matrix = new Matrix())
+                    {
+                        matrix.Translate(dx, dy);
+                        path.Transform(matrix);
+                    }
+                    graphics.FillPath(textBrush, path);
+                }
+            }
+
+            // Do not destroy this HICON: the taskbar retains the overlay after
+            // this one-shot helper exits. Windows reclaims the icon with the
+            // helper's process resources.
+            string description = overflow ? "More than 3 completed sessions" : (count == 1 ? "1 completed session" : count + " completed sessions");
+            taskbar.SetOverlayIcon(hwnd, bitmap.GetHicon(), description);
+        }
+    }
+}

package/lib/taskbar-badge-main.cs

@@ -0,0 +1,43 @@
+using System;
+
+/// <summary>
+/// Standalone entry point for the one-shot taskbar overlay writer.
+/// Running a precompiled small executable avoids starting Windows PowerShell
+/// (and loading its ~50 MB runtime) for every badge count change.
+/// </summary>
+public static class Program
+{
+    [STAThread]
+    public static int Main(string[] args)
+    {
+        long hwnd = 0;
+        int count = 0;
+
+        for (int i = 0; i < args.Length; i++)
+        {
+            string arg = args[i] ?? string.Empty;
+            if (string.Equals(arg, "-WarmOnly", StringComparison.OrdinalIgnoreCase)) return 0;
+            if (string.Equals(arg, "-Hwnd", StringComparison.OrdinalIgnoreCase) && i + 1 < args.Length)
+            {
+                long.TryParse(args[++i], out hwnd);
+                continue;
+            }
+            if (string.Equals(arg, "-Count", StringComparison.OrdinalIgnoreCase) && i + 1 < args.Length)
+            {
+                int.TryParse(args[++i], out count);
+                continue;
+            }
+        }
+
+        if (hwnd == 0) return 2;
+        try
+        {
+            DshTaskbarBadge.Set(new IntPtr(hwnd), count);
+            return 0;
+        }
+        catch
+        {
+            return 1;
+        }
+    }
+}