pinokiod 3.180.0 → 3.181.0

package/kernel/favicon.js

@@ -1,55 +1,112 @@
 const axios = require('axios')
-const { URL } = require("url");
-const { JSDOM } = require("jsdom");
+const { URL } = require('url')
+const { JSDOM } = require('jsdom')
 
 class Favicon {
+  constructor(opts = {}) {
+    this.cache = new Map() // origin -> { url: string|null, ts: number }
+    this.ttlMs = opts.ttlMs || (10 * 60 * 1000) // 10 minutes
+    this.headTimeoutMs = opts.headTimeoutMs || 800
+    this.getTimeoutMs = opts.getTimeoutMs || 700
+    this.totalBudgetMs = opts.totalBudgetMs || 900
+    this.commonPaths = Array.isArray(opts.commonPaths) && opts.commonPaths.length > 0
+      ? opts.commonPaths
+      : ['/favicon.ico', '/favicon.png']
+  }
+
+  _now() {
+    return Date.now()
+  }
+
+  _getCache(origin) {
+    const entry = this.cache.get(origin)
+    if (!entry) return null
+    if (this._now() - entry.ts > this.ttlMs) {
+      this.cache.delete(origin)
+      return null
+    }
+    return entry.url
+  }
+
+  _setCache(origin, url) {
+    this.cache.set(origin, { url: url || null, ts: this._now() })
+  }
+
   async get(pageUrl) {
-    let origin;
+    let origin
     try {
-      origin = new URL(pageUrl).origin;
+      origin = new URL(pageUrl).origin
     } catch {
-      throw new Error("Invalid URL: " + pageUrl);
+      throw new Error('Invalid URL: ' + pageUrl)
     }
 
-    const candidates = [
-      "/favicon.ico",
-      "/favicon.png",
-      "/assets/favicon.ico",
-      "/static/favicon.ico",
-      "/favicon.svg",
-    ];
-
-    // 1. Try common favicon paths first
-    for (const path of candidates) {
-      const fullUrl = origin + path;
-      if (await this.checkImageUrl(fullUrl)) return fullUrl;
+    const cached = this._getCache(origin)
+    if (typeof cached !== 'undefined' && cached !== null) {
+      return cached
+    } else if (cached === null) {
+      // we cached a miss previously
+      return null
     }
 
-    // 2. Fallback to parsing HTML
+    const start = this._now()
+    const withinBudget = () => (this._now() - start) < this.totalBudgetMs
+
+    // 1) Try common paths (limited set) in parallel, with short HEAD timeouts
     try {
-      const res = await axios.get(pageUrl, { timeout: 1000 });
-      const dom = new JSDOM(res.data);
-      const icons = Array.from(dom.window.document.querySelectorAll("link[rel~='icon'], link[rel='apple-touch-icon']"));
-
-      for (const icon of icons) {
-        const href = icon.getAttribute("href");
-        if (!href) continue;
-        const resolvedUrl = new URL(href, origin).href;
-        if (await this.checkImageUrl(resolvedUrl)) return resolvedUrl;
+      const attempts = this.commonPaths.map((p) => this.checkImageUrl(origin + p, this.headTimeoutMs))
+      const results = await Promise.all(attempts)
+      for (let i = 0; i < results.length; i++) {
+        if (results[i]) {
+          const url = origin + this.commonPaths[i]
+          this._setCache(origin, url)
+          return url
+        }
       }
-    } catch {
-      // Ignore HTML errors
+    } catch (_) {}
+
+    if (!withinBudget()) {
+      this._setCache(origin, null)
+      return null
+    }
+
+    // 2) Fallback: fetch the page quickly, parse <link rel="icon">, then HEAD the first 1-2 candidates
+    try {
+      const res = await axios.get(pageUrl, { timeout: this.getTimeoutMs })
+      const dom = new JSDOM(res.data)
+      const nodes = Array.from(dom.window.document.querySelectorAll("link[rel~='icon'], link[rel='apple-touch-icon']"))
+      const hrefs = []
+      for (const node of nodes) {
+        const href = node.getAttribute('href')
+        if (href && typeof href === 'string') {
+          try {
+            const resolved = new URL(href, origin).href
+            hrefs.push(resolved)
+          } catch (_) {}
+        }
+      }
+      // Try at most 2 parsed icons within budget
+      for (let i = 0; i < Math.min(2, hrefs.length); i++) {
+        if (!withinBudget()) break
+        const ok = await this.checkImageUrl(hrefs[i], this.headTimeoutMs)
+        if (ok) {
+          this._setCache(origin, hrefs[i])
+          return hrefs[i]
+        }
+      }
+    } catch (_) {
+      // ignore parse failures
     }
 
-    return null;
+    this._setCache(origin, null)
+    return null
   }
 
-  async checkImageUrl(url) {
+  async checkImageUrl(url, timeoutOverride) {
     try {
-      const res = await axios.head(url, { timeout: 3000 });
-      return res.status === 200 && res.headers["content-type"]?.startsWith("image/");
+      const res = await axios.head(url, { timeout: timeoutOverride || this.headTimeoutMs })
+      return res.status === 200 && (res.headers['content-type'] || '').startsWith('image/')
     } catch {
-      return false;
+      return false
     }
   }
 }

package/kernel/peer.js

@@ -337,6 +337,79 @@ class PeerDiscovery {
       return []
     }
   }
+  async router_info_lite() {
+    try {
+      let processes = []
+      if (this.info && this.info[this.host]) {
+        let procs = this.info[this.host].proc
+        let router = this.info[this.host].router
+        let port_mapping = this.info[this.host].port_mapping
+        for (let proc of procs) {
+          let chunks = (proc.ip || '').split(":")
+          let internal_port = chunks[chunks.length - 1]
+          let internal_host = chunks.slice(0, chunks.length - 1).join(":")
+          let external_port = port_mapping ? port_mapping[internal_port] : undefined
+          let external_ip = external_port ? `${this.host}:${external_port}` : undefined
+
+          let internal_router = []
+          // Check common local keys
+          const keys = [
+            `127.0.0.1:${proc.port}`,
+            `0.0.0.0:${proc.port}`,
+            `localhost:${proc.port}`,
+          ]
+          for (const key of keys) {
+            if (router && router[key]) {
+              internal_router = internal_router.concat(router[key])
+            }
+          }
+
+          const info = {
+            external_router: (router && external_ip && router[external_ip]) ? router[external_ip] : [],
+            internal_router,
+            external_ip,
+            external_port: external_port ? parseInt(external_port) : undefined,
+            internal_port: internal_port ? parseInt(internal_port) : undefined,
+            ...proc,
+          }
+
+          // In custom-domain mode, ensure external_router has something meaningful
+          const usingCustomDomain = this.kernel.router_kind === 'custom-domain'
+          if (usingCustomDomain) {
+            if (!info.external_router || info.external_router.length === 0) {
+              const fallbackKeys = new Set([
+                proc.ip,
+                `${internal_host}:${proc.port}`,
+                `127.0.0.1:${proc.port}`,
+                `0.0.0.0:${proc.port}`,
+                `localhost:${proc.port}`
+              ])
+              for (const key of fallbackKeys) {
+                if (key && router && router[key] && router[key].length > 0) {
+                  info.external_router = router[key]
+                  break
+                }
+              }
+            }
+            if (info.external_router && info.external_router.length > 0) {
+              info.external_router = Array.from(new Set(info.external_router))
+            } else if (internal_router.length > 0) {
+              info.external_router = Array.from(new Set(internal_router))
+            }
+          }
+
+          processes.push(info)
+        }
+      }
+      processes.sort((a, b) => {
+        return (b.external_port || 0) - (a.external_port || 0)
+      })
+      return processes
+    } catch (e) {
+      console.log('router_info_lite ERROR', e)
+      return []
+    }
+  }
   async installed() {
     let folders = await fs.promises.readdir(this.kernel.path("api"))
     let installed = []

package/kernel/util.js

@@ -698,6 +698,8 @@ function push(params) {
     }
   }
   const clientImage = resolvePublicAssetUrl(notifyParams.contentImage) || resolvePublicAssetUrl(notifyParams.image)
+  const deviceId = (typeof notifyParams.device_id === 'string' && notifyParams.device_id.trim()) ? notifyParams.device_id.trim() : null
+  const audience = (typeof notifyParams.audience === 'string' && notifyParams.audience.trim()) ? notifyParams.audience.trim() : null
   const eventPayload = {
     id: randomUUID(),
     title: notifyParams.title,
@@ -707,11 +709,20 @@ function push(params) {
     sound: clientSoundUrl || null,
     timestamp: Date.now(),
     platform,
+    device_id: deviceId,
+    audience,
   }
 
   emitPushEvent(eventPayload)
-
-  notifier.notify(notifyParams)
+  // Suppress host OS notification when explicitly disabled (e.g., device-scoped pushes)
+  const shouldNotifyHost = notifyParams.host !== false
+  if (shouldNotifyHost) {
+    const notifyCopy = { ...notifyParams }
+    delete notifyCopy.host
+    delete notifyCopy.device_id
+    delete notifyCopy.audience
+    notifier.notify(notifyCopy)
+  }
 }
 function p2u(localPath) {
   /*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "3.180.0",
+  "version": "3.181.0",
   "description": "",
   "main": "index.js",
   "scripts": {

package/server/index.js

@@ -1509,10 +1509,15 @@ class Server {
           drive: path.resolve(this.kernel.homedir, "drive"),
         }
       }
+      const peer_url = `http://${this.kernel.peer.host}:${DEFAULT_PORT}`
+      let peer_qr = null
+      try { peer_qr = await QRCode.toDataURL(peer_url) } catch (_) {}
       let list = this.getPeers()
       res.render("settings", {
         list,
         current_host: this.kernel.peer.host,
+        peer_url,
+        peer_qr,
         platform,
         version: this.version,
         logo: this.logo,
@@ -2234,6 +2239,10 @@ class Server {
         qr_cloudflare = await QRCode.toDataURL(this.cloudflare_pub)
       }
 
+      const peer_url = `http://${this.kernel.peer.host}:${DEFAULT_PORT}`
+      let peer_qr = null
+      try { peer_qr = await QRCode.toDataURL(peer_url) } catch (_) {}
+
       // custom theme
       let exists = await fse.pathExists(this.kernel.path("web"))
       if (exists) {
@@ -2263,6 +2272,8 @@ class Server {
         res.render("index", {
           list,
           current_host: this.kernel.peer.host,
+          peer_url,
+          peer_qr,
           current_urls,
           portal: this.portal,
           install: this.install,
@@ -3924,6 +3935,9 @@ class Server {
     }))
     */
     this.app.get("/tools", ex(async (req, res) => {
+      const peer_url = `http://${this.kernel.peer.host}:${DEFAULT_PORT}`
+      let peer_qr = null
+      try { peer_qr = await QRCode.toDataURL(peer_url) } catch (_) {}
       let list = this.getPeers()
       let installs = []
       for(let key in this.kernel.bin.installed) {
@@ -3955,6 +3969,8 @@ class Server {
       }
       res.render("tools", {
         current_host: this.kernel.peer.host,
+        peer_url,
+        peer_qr,
         pending,
         installs,
         bundles,
@@ -4039,9 +4055,14 @@ class Server {
         return (a.name || '').localeCompare(b.name || '')
       })
 
+      const peer_url = `http://${this.kernel.peer.host}:${DEFAULT_PORT}`
+      let peer_qr = null
+      try { peer_qr = await QRCode.toDataURL(peer_url) } catch (_) {}
       const list = this.getPeers()
       res.render("terminals", {
         current_host: this.kernel.peer.host,
+        peer_url,
+        peer_qr,
         pluginMenu,
         apps,
         portal: this.portal,
@@ -4055,9 +4076,14 @@ class Server {
       res.redirect(301, "/terminals")
     })
     this.app.get("/screenshots", ex(async (req, res) => {
+      const peer_url = `http://${this.kernel.peer.host}:${DEFAULT_PORT}`
+      let peer_qr = null
+      try { peer_qr = await QRCode.toDataURL(peer_url) } catch (_) {}
       let list = this.getPeers()
       res.render("screenshots", {
         current_host: this.kernel.peer.host,
+        peer_url,
+        peer_qr,
         version: this.version,
         portal: this.portal,
         logo: this.logo,
@@ -4144,6 +4170,7 @@ class Server {
         // if <app_name>.localhost
         // otherwise => redirect
 
+        console.log("Chunks", chunks)
 
         if (chunks.length >= 2) {
 
@@ -4190,29 +4217,31 @@ class Server {
         } else {
           nameChunks = chunks
         }
-        let name = nameChunks.join(".")
-        let api_path = this.kernel.path("api", name)
-        let exists = await this.exists(api_path)
-        if (exists) {
-          let meta = await this.kernel.api.meta(name)
-          let launcher = await this.kernel.api.launcher(name)
-          let pinokio = launcher.script
-          let launchable = false
-          if (pinokio && pinokio.menu && pinokio.menu.length > 0) {
-            launchable = true
-          }
-          res.render("start", {
-            url,
-            launchable,
-            autolaunch,
-            logo: this.logo,
-            theme: this.theme,
-            agent: req.agent,
-            name: meta.title,
-            image: meta.icon,
-            link: `/p/${name}?autolaunch=${autolaunch ? "1" : "0"}`,
-          })
-          return
+        if (nameChunks) {
+          let name = nameChunks.join(".")
+          let api_path = this.kernel.path("api", name)
+          let exists = await this.exists(api_path)
+          if (exists) {
+            let meta = await this.kernel.api.meta(name)
+            let launcher = await this.kernel.api.launcher(name)
+            let pinokio = launcher.script
+            let launchable = false
+            if (pinokio && pinokio.menu && pinokio.menu.length > 0) {
+              launchable = true
+            }
+            res.render("start", {
+              url,
+              launchable,
+              autolaunch,
+              logo: this.logo,
+              theme: this.theme,
+              agent: req.agent,
+              name: meta.title,
+              image: meta.icon,
+              link: `/p/${name}?autolaunch=${autolaunch ? "1" : "0"}`,
+            })
+            return
+          }
         }
       }
       res.render("start", {
@@ -4325,9 +4354,14 @@ class Server {
             drive: path.resolve(this.kernel.homedir, "drive"),
           }
         }
+        const peer_url = `http://${this.kernel.peer.host}:${DEFAULT_PORT}`
+        let peer_qr = null
+        try { peer_qr = await QRCode.toDataURL(peer_url) } catch (_) {}
         let list = this.getPeers()
         res.render("settings", {
           current_host: this.kernel.peer.host,
+          peer_url,
+          peer_qr,
           list,
           platform,
           version: this.version,
@@ -4443,6 +4477,9 @@ class Server {
         return
       }
 
+      const peer_url = `http://${this.kernel.peer.host}:${DEFAULT_PORT}`
+      let peer_qr = null
+      try { peer_qr = await QRCode.toDataURL(peer_url) } catch (_) {}
       let list = this.getPeers()
       let ai = await this.kernel.proto.ai()
       ai = [{
@@ -4456,6 +4493,8 @@ class Server {
         list,
         ai,
         current_host: this.kernel.peer.host,
+        peer_url,
+        peer_qr,
         cwd: this.kernel.path("api"),
         name: null,
 //        name: req.params.name,
@@ -4556,9 +4595,14 @@ class Server {
         } catch (e) {
         }
       }
+      const peer_url = `http://${this.kernel.peer.host}:${DEFAULT_PORT}`
+      let peer_qr = null
+      try { peer_qr = await QRCode.toDataURL(peer_url) } catch (_) {}
       res.render(`connect`, {
         current_urls,
         current_host: this.kernel.peer.host,
+        peer_url,
+        peer_qr,
         list,
         portal: this.portal,
         logo: this.logo,
@@ -4700,6 +4744,13 @@ class Server {
     this.app.post("/push", ex(async (req, res) => {
       try {
         const payload = { ...(req.body || {}) }
+        // Normalise audience and device targeting
+        if (typeof payload.audience === 'string') {
+          payload.audience = payload.audience.trim() || undefined
+        }
+        if (typeof payload.device_id === 'string') {
+          payload.device_id = payload.device_id.trim() || undefined
+        }
         const resolveAssetPath = (raw) => {
           if (typeof raw !== 'string') {
             return null
@@ -4782,6 +4833,19 @@ class Server {
         }
         delete payload.soundUrl
         delete payload.soundPath
+        // For device-scoped notifications, suppress host OS notifier for remote origins,
+        // but allow it when the request originates from the local machine
+        if (payload.audience === 'device' && typeof payload.device_id === 'string' && payload.device_id) {
+          try {
+            if (this.socket && typeof this.socket.isLocalDevice === 'function') {
+              payload.host = !!this.socket.isLocalDevice(payload.device_id)
+            } else {
+              payload.host = false
+            }
+          } catch (_) {
+            payload.host = false
+          }
+        }
         Util.push(payload)
         res.json({ success: true })
       } catch (e) {
@@ -5343,6 +5407,9 @@ class Server {
       let static_routes = Object.keys(this.kernel.router.rewrite_mapping).map((key) => {
         return this.kernel.router.rewrite_mapping[key]
       })
+      const peer_url = `http://${this.kernel.peer.host}:${DEFAULT_PORT}`
+      let peer_qr = null
+      try { peer_qr = await QRCode.toDataURL(peer_url) } catch (_) {}
       res.render("net", {
         static_routes,
         selected_name: req.params.name,
@@ -5361,6 +5428,8 @@ class Server {
         peer,
         protocol,
         current_host: this.kernel.peer.host,
+        peer_url,
+        peer_qr,
       })
     }))
     this.app.get("/network", ex(async (req, res) => {
@@ -5502,6 +5571,9 @@ class Server {
       let static_routes = Object.keys(this.kernel.router.rewrite_mapping).map((key) => {
         return this.kernel.router.rewrite_mapping[key]
       })
+      const peer_url = `http://${this.kernel.peer.host}:${DEFAULT_PORT}`
+      let peer_qr = null
+      try { peer_qr = await QRCode.toDataURL(peer_url) } catch (_) {}
       res.render("network", {
         static_routes,
         host,
@@ -5527,6 +5599,8 @@ class Server {
         peer_active: this.kernel.peer.active,
         port_mapping: this.kernel.router.port_mapping,
 //        port_mapping: this.kernel.caddy.port_mapping,
+        peer_url,
+        peer_qr,
 //        ip_mapping: this.kernel.caddy.ip_mapping,
         lan: this.kernel.router.local_network_mapping,
         agent: req.agent,
@@ -7059,6 +7133,35 @@ class Server {
       let current_peer_info = await this.kernel.peer.current_host()
       res.json(current_peer_info)
     }))
+    this.app.get("/info/router", ex(async (req, res) => {
+      try {
+        // Lightweight router mapping without favicon or installed scans
+        const https_active = this.kernel.peer.https_active
+        const router_info = await this.kernel.peer.router_info_lite()
+        const rewrite_mapping = this.kernel.router.rewrite_mapping
+        const router = this.kernel.router.published()
+        res.json({ https_active, router_info, rewrite_mapping, router })
+      } catch (err) {
+        res.json({ https_active: false, router_info: [], rewrite_mapping: {}, router: {} })
+      }
+    }))
+    this.app.get("/qr", ex(async (req, res) => {
+      try {
+        const data = typeof req.query.data === 'string' ? req.query.data : ''
+        if (!data) {
+          res.status(400).json({ error: 'Missing data parameter' })
+          return
+        }
+        const scale = Math.max(2, Math.min(10, parseInt(req.query.s || '4', 10) || 4))
+        const margin = Math.max(0, Math.min(4, parseInt(req.query.m || '0', 10) || 0))
+        const buf = await QRCode.toBuffer(data, { type: 'png', scale, margin })
+        res.setHeader('Content-Type', 'image/png')
+        res.setHeader('Cache-Control', 'no-store')
+        res.send(buf)
+      } catch (err) {
+        res.status(500).json({ error: 'Failed to generate QR' })
+      }
+    }))
     this.app.get("/info/api", ex(async (req,res) => {
       // api related info
       let repo = this.kernel.git.find(req.query.git)