pinokiod 3.170.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.170.0",
+  "version": "3.181.0",
   "description": "",
   "main": "index.js",
   "scripts": {