pinokiod 3.130.0 → 3.131.0

package/kernel/api/push/index.js

@@ -1,21 +1,25 @@
 /*
   {
     method: "push",
-    params: {
+  params: {
       title: <string>,
       subtitle: <string>, 
       message: <string>,
       image: <image path>,
-      sound: true|false,
-    }
+      sound: true|false|string,
   }
+}
 (*/
 const util = require('../../util')
 const path = require('path');
 module.exports = async (req, ondata, kernel) => {
-  let params = req.params
-  if (params.image) {
+  const params = { ...(req.params || {}) }
+  if (typeof params.image === 'string') {
     params.image = path.resolve(req.cwd, params.image)
   }
+  if (typeof params.sound === 'string') {
+    const trimmed = params.sound.trim()
+    params.sound = trimmed || undefined
+  }
   util.push(params)
 }

package/kernel/util.js

@@ -1,8 +1,8 @@
 const fs = require('fs')
-const { spawn } = require('child_process')
+const { spawn, spawnSync } = require('child_process')
 const Clipboard = require('copy-paste/promises');
 const http = require('http');
-const notifier = require('node-notifier');
+const notifier = require('toasted-notifier');
 const os = require('os')
 const net = require('node:net')
 const path = require('path')
@@ -12,6 +12,11 @@ const retry = require('async-retry');
 const child_process = require('node:child_process');
 const {auto: normalizeEOL} = require("eol");
 const {EOL} = require("os");
+const axios = require('axios');
+const { pipeline } = require('stream/promises');
+const { pathToFileURL } = require('url');
+const { randomUUID } = require('crypto');
+const fsp = fs.promises;
 const breakPattern = /\n/g;
 const breakReplacement = "\\n";
 const groupPattern = /\$/g;
@@ -24,7 +29,26 @@ const {
 } = require('glob')
 
 
-  const platform = os.platform()
+const platform = os.platform()
+function ensureNotifierBinaries() {
+  if (platform !== 'darwin') {
+    return
+  }
+  try {
+    const notifierModulePath = require.resolve('toasted-notifier/notifiers/notificationcenter')
+    const binaryPath = path.resolve(path.dirname(notifierModulePath), '../vendor/mac.noindex/terminal-notifier.app/Contents/MacOS/terminal-notifier')
+    if (!fs.existsSync(binaryPath)) {
+      return
+    }
+    const mode = fs.statSync(binaryPath).mode & 0o777
+    if ((mode & 0o111) === 0) {
+      fs.chmodSync(binaryPath, mode | 0o755)
+    }
+  } catch (err) {
+    console.warn('Warning: unable to update terminal-notifier permissions:', err.message)
+  }
+}
+ensureNotifierBinaries()
 // asar handling for go-get-folder-size
 let g
 if( __dirname.includes(".asar") ) {
@@ -530,6 +554,147 @@ function fill_object(obj, pattern, list, cache) {
   let res = recurse(obj);
   return { result: res, replaced_map }
 }
+const isNonEmptyString = (value) => typeof value === 'string' && value.trim().length > 0
+const HTTP_URL_REGEX = /^https?:\/\//i
+const linuxSoundCandidates = [
+  { cmd: 'paplay', args: (filePath) => [filePath] },
+  { cmd: 'aplay', args: (filePath) => [filePath] },
+  { cmd: 'ffplay', args: (filePath) => ['-autoexit', '-nodisp', filePath] },
+  { cmd: 'mpg123', args: (filePath) => [filePath] },
+  { cmd: 'mplayer', args: (filePath) => [filePath] },
+  { cmd: 'cvlc', args: (filePath) => ['--play-and-exit', filePath] },
+]
+let cachedLinuxSoundPlayer
+const DEFAULT_CHIME_PATH = path.resolve(__dirname, '../server/public/chime.mp3')
+function pickLinuxSoundPlayer() {
+  if (cachedLinuxSoundPlayer !== undefined) {
+    return cachedLinuxSoundPlayer
+  }
+  for (const candidate of linuxSoundCandidates) {
+    try {
+      const lookup = spawnSync('which', [candidate.cmd], { stdio: 'ignore' })
+      if (lookup.status === 0) {
+        cachedLinuxSoundPlayer = candidate
+        return cachedLinuxSoundPlayer
+      }
+    } catch (_) {
+      // ignore lookup errors and try next candidate
+    }
+  }
+  cachedLinuxSoundPlayer = null
+  return cachedLinuxSoundPlayer
+}
+function extractUrlExtension(rawUrl) {
+  try {
+    const parsed = new URL(rawUrl)
+    const ext = path.extname(parsed.pathname)
+    if (ext && ext.length <= 6) {
+      return ext
+    }
+  } catch (_) {
+    // ignore URL parse errors
+  }
+  return ''
+}
+async function downloadSoundToTemp(url) {
+  const tempPath = path.join(os.tmpdir(), `pinokio-notify-${randomUUID()}${extractUrlExtension(url)}`)
+  const response = await axios.get(url, {
+    responseType: 'stream',
+    timeout: 15000,
+  })
+  await pipeline(response.data, fs.createWriteStream(tempPath))
+  return {
+    filePath: tempPath,
+    cleanup: async () => {
+      try {
+        await fsp.unlink(tempPath)
+      } catch (_) {
+        // best-effort cleanup
+      }
+    }
+  }
+}
+function playSoundFile(filePath) {
+  if (!filePath) {
+    return null
+  }
+  if (platform === 'darwin') {
+    return spawn('afplay', [filePath], { stdio: 'ignore' })
+  }
+  if (platform === 'win32') {
+    const fileUrl = pathToFileURL(filePath).href.replace(/'/g, "''")
+    const script = [
+      "$ErrorActionPreference = 'Stop'",
+      "Add-Type -AssemblyName presentationCore",
+      "$player = New-Object system.windows.media.mediaplayer",
+      `$player.Open([Uri]'${fileUrl}')`,
+      "$player.Play()",
+      "while ($player.NaturalDuration.HasTimeSpan -eq $false) { Start-Sleep -Milliseconds 100 }",
+      "Start-Sleep -Seconds $player.NaturalDuration.TimeSpan.TotalSeconds",
+    ].join('; ')
+    return spawn('powershell.exe', ['-NoProfile', '-NonInteractive', '-WindowStyle', 'Hidden', '-Command', script], {
+      stdio: 'ignore'
+    })
+  }
+  const candidate = pickLinuxSoundPlayer()
+  if (!candidate) {
+    throw new Error('No supported audio player found for Linux (expected one of paplay, aplay, ffplay, mpg123, mplayer, cvlc).')
+  }
+  return spawn(candidate.cmd, candidate.args(filePath), { stdio: 'ignore' })
+}
+function scheduleSoundPlayback(target) {
+  if (!target) {
+    return
+  }
+  ;(async () => {
+    let cleanup = null
+    try {
+      let filePath
+      if (target.kind === 'file') {
+        filePath = target.value
+      } else if (target.kind === 'url') {
+        if (!HTTP_URL_REGEX.test(target.value)) {
+          throw new Error(`Unsupported sound URL: ${target.value}`)
+        }
+        const downloaded = await downloadSoundToTemp(target.value)
+        filePath = downloaded.filePath
+        cleanup = downloaded.cleanup
+      } else {
+        return
+      }
+
+      const child = playSoundFile(filePath)
+      if (!child) {
+        if (cleanup) {
+          cleanup().catch(() => {})
+        }
+        return
+      }
+
+      const tidy = () => {
+        if (!cleanup) {
+          return
+        }
+        cleanup().catch((err) => {
+          console.error('Failed to clean up temporary sound file:', err)
+        })
+      }
+
+      child.once('close', tidy)
+      child.once('error', tidy)
+      child.on('error', (err) => {
+        console.error('Failed to play notification sound:', err)
+      })
+    } catch (err) {
+      if (cleanup) {
+        cleanup().catch(() => {})
+      }
+      console.error('Failed to play notification sound:', err)
+    }
+  })().catch((err) => {
+    console.error('Failed to play notification sound:', err)
+  })
+}
 function push(params) {
   /*
   params :- {
@@ -537,23 +702,39 @@ function push(params) {
     subtitle: <string>, 
     message: <string>,
     image: <image path>,
-    sound: true|false,
+    sound: true|false|string, // true uses default chime
   }
   */
-  if (params.sound) {
-    params.sound = "Funk"
+  const notifyParams = { ...(params || {}) }
+  const customSoundTarget = (() => {
+    if (notifyParams.sound === true) {
+      return { kind: 'file', value: DEFAULT_CHIME_PATH }
+    }
+    if (isNonEmptyString(notifyParams.sound)) {
+      const trimmed = notifyParams.sound.trim()
+      if (!trimmed) {
+        return null
+      }
+      return { kind: 'url', value: trimmed }
+    }
+    return null
+  })()
+
+  if (notifyParams.image && !notifyParams.contentImage) {
+    notifyParams.contentImage = notifyParams.image
   }
-  // Blow, Bottle, Funk, Glass, Morse, Tink.
-  if (params.image && !params.contentImage) {
-    params.contentImage = params.image
+  if (!notifyParams.title) {
+    notifyParams.title = "Pinokio"
   }
-  if (!params.title) {
-    params.title = "Pinokio"
+  if (!notifyParams.contentImage) {
+    notifyParams.contentImage = path.resolve(__dirname, "../server/public/pinokio-black.png")
   }
-  if (!params.contentImage) {
-    params.contentImage = path.resolve(__dirname, "../server/public/pinokio-black.png")
+  if (customSoundTarget) {
+    notifyParams.sound = false
+    scheduleSoundPlayback(customSoundTarget)
   }
-  notifier.notify(params)
+  console.log("notifyParams", notifyParams)
+  notifier.notify(notifyParams)
 }
 function p2u(localPath) {
   /*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "3.130.0",
+  "version": "3.131.0",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -60,7 +60,6 @@
     "multer": "^1.4.5-lts.1",
     "node-downloader-helper": "^2.1.9",
     "node-gradio-client": "^0.14.6",
-    "node-notifier": "^10.0.1",
     "normalize-path": "^3.0.0",
     "p-limit": "^3.1.0",
     "parseurl": "^1.3.3",
@@ -77,6 +76,7 @@
     "sudo-prompt-programfiles-x86": "^9.2.10",
     "symlink-dir": "^5.2.1",
     "systeminformation": "^5.18.4",
+    "toasted-notifier": "^10.1.0",
     "twitter-api-v2": "^1.23.2",
     "uuid": "^9.0.0",
     "wait-on": "^7.2.0",

package/server/index.js

@@ -4521,64 +4521,88 @@ class Server {
       console.log("Push", req.body)
       try {
         const payload = { ...(req.body || {}) }
-        if (typeof payload.image === 'string' && payload.image.trim()) {
-          const resolveAssetPath = (raw) => {
-            if (typeof raw !== 'string') {
-              return null
-            }
-            const trimmed = raw.trim()
-            if (!trimmed) {
-              return null
-            }
-            let candidate = trimmed
-            if (/^https?:\/\//i.test(trimmed)) {
-              try {
-                const parsed = new URL(trimmed)
-                candidate = parsed.pathname
-              } catch (_) {
-                return null
-              }
-            }
-            if (!candidate.startsWith('/asset/')) {
-              return null
-            }
-            const pathPart = candidate.split('?')[0].split('#')[0]
-            const rel = pathPart.replace(/^\/asset\/+/, '')
-            if (!rel) {
-              return null
-            }
-            const parts = rel.split('/').filter(Boolean)
-            if (!parts.length || parts.some((part) => part === '..')) {
-              return null
-            }
+        const resolveAssetPath = (raw) => {
+          if (typeof raw !== 'string') {
+            return null
+          }
+          const trimmed = raw.trim()
+          if (!trimmed) {
+            return null
+          }
+          let candidate = trimmed
+          if (/^https?:\/\//i.test(trimmed)) {
             try {
-              return this.kernel.path(...parts)
+              const parsed = new URL(trimmed)
+              candidate = parsed.pathname
             } catch (_) {
               return null
             }
           }
-          const resolvedImage = resolveAssetPath(payload.image)
+          if (!candidate.startsWith('/asset/')) {
+            return null
+          }
+          const pathPart = candidate.split('?')[0].split('#')[0]
+          const rel = pathPart.replace(/^\/asset\/+/, '')
+          if (!rel) {
+            return null
+          }
+          const parts = rel.split('/').filter(Boolean)
+          if (!parts.length || parts.some((part) => part === '..')) {
+            return null
+          }
+          try {
+            return this.kernel.path(...parts)
+          } catch (_) {
+            return null
+          }
+        }
+        const resolvePublicAsset = async (raw) => {
+          if (typeof raw !== 'string') {
+            return null
+          }
+          const trimmed = raw.trim()
+          if (!trimmed || !trimmed.startsWith('/')) {
+            return null
+          }
+          const relative = trimmed.replace(/^\/+/, '')
+          if (!relative) {
+            return null
+          }
+          const publicRoot = path.resolve(__dirname, 'public')
+          const candidate = path.resolve(publicRoot, relative)
+          if (!candidate.startsWith(publicRoot)) {
+            return null
+          }
+          try {
+            await fs.promises.access(candidate, fs.constants.R_OK)
+            return candidate
+          } catch (_) {
+            return null
+          }
+        }
+        const normaliseNotificationAsset = async (raw) => {
+          const asset = resolveAssetPath(raw)
+          if (asset) {
+            return asset
+          }
+          const fallback = await resolvePublicAsset(raw)
+          if (fallback) {
+            return fallback
+          }
+          return null
+        }
+        if (typeof payload.image === 'string' && payload.image.trim()) {
+          const resolvedImage = await normaliseNotificationAsset(payload.image)
           if (resolvedImage) {
             payload.image = resolvedImage
-          } else {
-            const normalised = payload.image.trim()
-            if (normalised.startsWith('/')) {
-              const relative = normalised.replace(/^\/+/, '')
-              if (relative) {
-                const publicRoot = path.resolve(__dirname, 'public')
-                const candidate = path.resolve(publicRoot, relative)
-                if (candidate.startsWith(publicRoot)) {
-                  try {
-                    await fs.promises.access(candidate, fs.constants.R_OK)
-                    payload.image = candidate
-                  } catch (_) {
-                    // ignore missing fallback asset
-                  }
-                }
-              }
-            }
           }
         }
+        if (typeof payload.sound === 'string') {
+          const trimmedSound = payload.sound.trim()
+          payload.sound = trimmedSound || undefined
+        }
+        delete payload.soundUrl
+        delete payload.soundPath
         Util.push(payload)
         res.json({ success: true })
       } catch (e) {