pinokiod 3.134.0 → 3.135.0

package/kernel/util.js

@@ -30,6 +30,70 @@ const {
 
 
 const platform = os.platform()
+const WINDOWS_TOAST_APP_ID = process.env.PINOKIO_WINDOWS_APP_ID || 'computer.pinokio'
+const DEFAULT_CHIME_URL_PATH = '/chime.mp3'
+const pushListeners = new Set()
+
+function registerPushListener(listener) {
+  if (typeof listener !== 'function') {
+    throw new TypeError('push listener must be a function')
+  }
+  pushListeners.add(listener)
+  return () => pushListeners.delete(listener)
+}
+
+function emitPushEvent(event) {
+  if (!event) {
+    return
+  }
+  pushListeners.forEach((listener) => {
+    try {
+      listener(event)
+    } catch (err) {
+      console.error('Push listener error:', err)
+    }
+  })
+}
+
+function resolvePublicAssetUrl(filePath) {
+  if (!filePath) {
+    return null
+  }
+  if (/^https?:\/\//i.test(filePath)) {
+    return filePath
+  }
+  try {
+    const absolute = path.resolve(filePath)
+    const publicRoot = path.resolve(__dirname, '../server/public')
+    if (absolute === publicRoot) {
+      return '/'
+    }
+    if (absolute.startsWith(publicRoot + path.sep) || absolute === publicRoot) {
+      const relative = path.relative(publicRoot, absolute).replace(/\\/g, '/')
+      return '/' + relative
+    }
+  } catch (_) {
+    // ignore resolution failures
+  }
+  return null
+}
+
+function soundTargetToClientUrl(target) {
+  if (!target) {
+    return null
+  }
+  if (target.kind === 'url') {
+    return target.value
+  }
+  if (target.kind === 'file') {
+    const resolved = path.resolve(target.value)
+    if (resolved === DEFAULT_CHIME_PATH) {
+      return DEFAULT_CHIME_URL_PATH
+    }
+    return resolvePublicAssetUrl(resolved)
+  }
+  return null
+}
 function ensureNotifierBinaries() {
   if (platform !== 'darwin') {
     return
@@ -729,10 +793,39 @@ function push(params) {
   if (!notifyParams.contentImage) {
     notifyParams.contentImage = path.resolve(__dirname, "../server/public/pinokio-black.png")
   }
+  if (platform === 'win32') {
+    // Ensure Windows toast branding aligns with Pinokio assets.
+    if (!notifyParams.icon && notifyParams.contentImage) {
+      notifyParams.icon = notifyParams.contentImage
+    }
+    if (!notifyParams.appID && !notifyParams.appName) {
+      notifyParams.appID = WINDOWS_TOAST_APP_ID
+    }
+  }
+
+  const clientSoundUrl = soundTargetToClientUrl(customSoundTarget)
   if (customSoundTarget) {
     notifyParams.sound = false
-    scheduleSoundPlayback(customSoundTarget)
+    const shouldPlayLocally = platform !== 'win32' || !clientSoundUrl
+    if (shouldPlayLocally) {
+      scheduleSoundPlayback(customSoundTarget)
+    }
+  }
+
+  const clientImage = resolvePublicAssetUrl(notifyParams.contentImage) || resolvePublicAssetUrl(notifyParams.image)
+  const eventPayload = {
+    id: randomUUID(),
+    title: notifyParams.title,
+    subtitle: notifyParams.subtitle || null,
+    message: notifyParams.message || '',
+    image: clientImage,
+    sound: clientSoundUrl,
+    timestamp: Date.now(),
+    platform,
   }
+
+  emitPushEvent(eventPayload)
+
   console.log("notifyParams", notifyParams)
   notifier.notify(notifyParams)
 }
@@ -1076,5 +1169,34 @@ const rewrite_localhost= (kernel, obj, source) => {
 
 
 module.exports = {
-  parse_env, log_path, api_path, api_name, update_env, parse_env_detail, openfs, port_running, du, is_port_available, find_python, find_venv, fill_object, run, openURL, u2p, p2u, log, diffLinesWithContext, classifyChange, push, filepicker, exists, clipboard, mergeLines, ignore_subrepos, rewrite_localhost, symlink, file_type
+  parse_env,
+  log_path,
+  api_path,
+  api_name,
+  update_env,
+  parse_env_detail,
+  openfs,
+  port_running,
+  du,
+  is_port_available,
+  find_python,
+  find_venv,
+  fill_object,
+  run,
+  openURL,
+  u2p,
+  p2u,
+  log,
+  diffLinesWithContext,
+  classifyChange,
+  push,
+  filepicker,
+  exists,
+  clipboard,
+  mergeLines,
+  ignore_subrepos,
+  rewrite_localhost,
+  symlink,
+  file_type,
+  registerPushListener,
 }

package/package.json

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

package/server/public/common.js

@@ -1398,14 +1398,323 @@ const open_url2 = (href, target, features) => {
     window.open(href, "_self", features)
   }
 }
-hotkeys("ctrl+t,cmd+t,ctrl+n,cmd+n", (e) => {
-  let agent = document.body.getAttribute("data-agent")
-  if (agent === "electron") {
-    window.open(location.href, "_blank", "pinokio")
+if (typeof hotkeys === 'function') {
+  hotkeys("ctrl+t,cmd+t,ctrl+n,cmd+n", (e) => {
+    let agent = document.body.getAttribute("data-agent")
+    if (agent === "electron") {
+      window.open(location.href, "_blank", "pinokio")
+    } else {
+      window.open(location.href, "_blank")
+    }
+  })
+}
+
+(function initNotificationAudioBridge() {
+  if (typeof window === 'undefined') {
+    return;
+  }
+  if (window.__pinokioNotificationAudioInitialized) {
+    return;
+  }
+  window.__pinokioNotificationAudioInitialized = true;
+
+  const CHANNEL_ID = 'kernel.notifications';
+  const pendingSounds = [];
+  let isPlaying = false;
+  let currentSocket = null;
+  let reconnectTimeout = null;
+  let activeAudio = null;
+
+  const leaderStorageKey = 'pinokio.notification.leader';
+  const leaderHeartbeatMs = 5000;
+  const leaderStaleMs = 15000;
+  const tabId = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  const storageEnabled = (() => {
+    try {
+      const testKey = '__pinokio_notification_test__';
+      localStorage.setItem(testKey, '1');
+      localStorage.removeItem(testKey);
+      return true;
+    } catch (_) {
+      return false;
+    }
+  })();
+  let isLeader = false;
+  let heartbeatTimer = null;
+  let leadershipCheckTimer = null;
+
+  const parseLeaderValue = (value) => {
+    if (!value) return null;
+    try {
+      return JSON.parse(value);
+    } catch (_) {
+      return null;
+    }
+  };
+
+  const writeHeartbeat = () => {
+    try {
+      localStorage.setItem(leaderStorageKey, JSON.stringify({ id: tabId, ts: Date.now() }));
+    } catch (err) {
+      console.warn('Notification leader heartbeat failed:', err);
+    }
+  };
+
+  const clearHeartbeat = () => {
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+  };
+
+  const stopSocket = () => {
+    if (currentSocket && typeof currentSocket.close === 'function') {
+      try {
+        currentSocket.close();
+      } catch (_) {
+        // ignore
+      }
+    }
+    currentSocket = null;
+  };
+
+  const stopAudio = () => {
+    pendingSounds.length = 0;
+    if (activeAudio) {
+      try {
+        activeAudio.pause();
+        activeAudio.currentTime = 0;
+      } catch (_) {
+        // ignore
+      }
+      activeAudio = null;
+    }
+    isPlaying = false;
+  };
+
+  const resignLeadership = () => {
+    if (!isLeader) {
+      return;
+    }
+    isLeader = false;
+    clearHeartbeat();
+    if (reconnectTimeout != null) {
+      clearTimeout(reconnectTimeout);
+      reconnectTimeout = null;
+    }
+    stopSocket();
+    stopAudio();
+    try {
+      const stored = parseLeaderValue(localStorage.getItem(leaderStorageKey));
+      if (stored && stored.id === tabId) {
+        localStorage.removeItem(leaderStorageKey);
+      }
+    } catch (_) {
+      // ignore
+    }
+  };
+
+  const startLeadership = () => {
+    if (isLeader) {
+      return;
+    }
+    isLeader = true;
+    writeHeartbeat();
+    if (!heartbeatTimer) {
+      heartbeatTimer = setInterval(writeHeartbeat, leaderHeartbeatMs);
+    }
+    connect();
+  };
+
+  const playNextSound = () => {
+    if (isPlaying) {
+      return;
+    }
+    const next = pendingSounds.shift();
+    if (!next) {
+      return;
+    }
+    isPlaying = true;
+    activeAudio = new Audio(next);
+    activeAudio.preload = 'auto';
+    const cleanup = () => {
+      if (!activeAudio) {
+        return;
+      }
+      activeAudio.removeEventListener('ended', handleEnded);
+      activeAudio.removeEventListener('error', handleError);
+      activeAudio = null;
+      isPlaying = false;
+      playNextSound();
+    };
+    const handleEnded = () => cleanup();
+    const handleError = (err) => {
+      console.error('Notification audio playback failed:', err);
+      cleanup();
+    };
+    activeAudio.addEventListener('ended', handleEnded, { once: true });
+    activeAudio.addEventListener('error', handleError, { once: true });
+    const playPromise = activeAudio.play();
+    if (playPromise && typeof playPromise.catch === 'function') {
+      playPromise.catch((err) => {
+        console.error('Notification audio play() rejected:', err);
+        cleanup();
+      });
+    }
+  };
+
+  const enqueueSound = (url) => {
+    if (!url) {
+      return;
+    }
+    pendingSounds.push(url);
+    playNextSound();
+  };
+
+  const handlePacket = (packet) => {
+    if (!packet || packet.id !== CHANNEL_ID || packet.type !== 'notification') {
+      return;
+    }
+    const payload = packet.data || {};
+    if (typeof payload.sound === 'string' && payload.sound) {
+      enqueueSound(payload.sound);
+    }
+  };
+
+  const attemptLeadership = () => {
+    if (isLeader) {
+      writeHeartbeat();
+      return;
+    }
+    let current = null;
+    try {
+      current = parseLeaderValue(localStorage.getItem(leaderStorageKey));
+    } catch (_) {
+      current = null;
+    }
+    const now = Date.now();
+    const isStale = !current || !current.ts || (now - current.ts) > leaderStaleMs;
+    if (isStale || (current && current.id === tabId)) {
+      writeHeartbeat();
+      const freshlyStored = parseLeaderValue(localStorage.getItem(leaderStorageKey));
+      if (freshlyStored && freshlyStored.id === tabId) {
+        startLeadership();
+      }
+    }
+  };
+
+  const scheduleReconnect = (delay) => {
+    if (!isLeader) {
+      return;
+    }
+    if (reconnectTimeout != null) {
+      return;
+    }
+    reconnectTimeout = setTimeout(() => {
+      reconnectTimeout = null;
+      connect();
+    }, delay);
+  };
+
+  const connect = () => {
+    if (!isLeader) {
+      return;
+    }
+    const SocketCtor = typeof window.Socket === 'function' ? window.Socket : (typeof Socket === 'function' ? Socket : null);
+    if (!SocketCtor) {
+      return;
+    }
+    if (typeof WebSocket === 'undefined') {
+      return;
+    }
+    if (currentSocket && currentSocket.ws && currentSocket.ws.readyState === WebSocket.OPEN) {
+      return;
+    }
+    if (currentSocket && typeof currentSocket.close === 'function') {
+      try {
+        currentSocket.close();
+      } catch (_) {
+        // ignore
+      }
+    }
+    const socket = new SocketCtor();
+    try {
+      const promise = socket.run(
+        {
+          method: CHANNEL_ID,
+          mode: 'listen',
+        },
+        handlePacket
+      );
+      currentSocket = socket;
+      promise.then(() => {
+        // Attempt to reconnect after a brief delay when the socket closes normally.
+        if (currentSocket === socket) {
+          currentSocket = null;
+          scheduleReconnect(1500);
+        }
+      }).catch((err) => {
+        console.warn('Notification listener socket closed with error:', err);
+        if (currentSocket === socket) {
+          currentSocket = null;
+          scheduleReconnect(2500);
+        }
+      });
+      window.__pinokioNotificationSocket = socket;
+    } catch (err) {
+      console.error('Failed to establish notification listener socket:', err);
+      scheduleReconnect(3000);
+    }
+  };
+
+  if (!storageEnabled) {
+    isLeader = true;
+    const start = () => connect();
+    if (document.readyState === 'loading') {
+      document.addEventListener('DOMContentLoaded', start, { once: true });
+    } else {
+      connect();
+    }
+    window.addEventListener('beforeunload', () => {
+      stopSocket();
+      stopAudio();
+    });
+    return;
+  }
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', connect, { once: true });
   } else {
-    window.open(location.href, "_blank")
+    connect();
   }
-})
+
+  if (!leadershipCheckTimer) {
+    leadershipCheckTimer = setInterval(attemptLeadership, leaderHeartbeatMs);
+  }
+
+  window.addEventListener('storage', (event) => {
+    if (event.key !== leaderStorageKey) {
+      return;
+    }
+    const data = parseLeaderValue(event.newValue);
+    if (data && data.id === tabId) {
+      startLeadership();
+    } else {
+      resignLeadership();
+    }
+  });
+
+  window.addEventListener('beforeunload', () => {
+    if (leadershipCheckTimer) {
+      clearInterval(leadershipCheckTimer);
+      leadershipCheckTimer = null;
+    }
+    resignLeadership();
+  });
+
+  // Attempt to become leader immediately on load.
+  attemptLeadership();
+})();
 const refreshParent = (e) => {
 //  if (window.parent === window.top) {
     window.parent.postMessage(e, "*")

package/server/socket.js

@@ -3,6 +3,7 @@ const WebSocket = require('ws');
 const path = require('path')
 const Util = require("../kernel/util")
 const Environment = require("../kernel/environment")
+const NOTIFICATION_CHANNEL = 'kernel.notifications'
 class Socket {
   constructor(parent) {
     this.buffer = {}
@@ -15,6 +16,8 @@ class Socket {
 //    this.kernel = parent.kernel
     const wss = new WebSocket.Server({ server: this.parent.server })
     this.subscriptions = new Map(); // Initialize a Map to store the WebSocket connections interested in each event
+    this.notificationChannel = NOTIFICATION_CHANNEL
+    this.notificationBridgeDispose = null
     this.parent.kernel.api.listen("server.socket", this.trigger.bind(this))
     wss.on('connection', (ws, request) => {
       ws._headers = request.headers;
@@ -25,8 +28,15 @@ class Socket {
       ws._origin = request.headers.origin;
       ws.on('close', () => {
         this.subscriptions.forEach((set, eventName) => {
+          if (!set) {
+            return;
+          }
           set.delete(ws);
+          if (set.size === 0) {
+            this.subscriptions.delete(eventName);
+          }
         });
+        this.checkNotificationBridge();
       });
       ws.on('message', async (message, isBinary) => {
         let req
@@ -217,7 +227,11 @@ class Socket {
     if (!this.subscriptions.has(id)) {
       this.subscriptions.set(id, new Set());
     }
-    this.subscriptions.get(id).add(ws);
+    const set = this.subscriptions.get(id)
+    set.add(ws);
+    if (set.size === 1 && id === this.notificationChannel) {
+      this.ensureNotificationBridge();
+    }
   }
   trigger(e) {
     // send to id session
@@ -321,6 +335,49 @@ class Socket {
       }
     }
   }
+
+  broadcastNotification(payload) {
+    if (!payload) {
+      return
+    }
+    const subscribers = this.subscriptions.get(this.notificationChannel)
+    if (!subscribers || subscribers.size === 0) {
+      return
+    }
+    const envelope = {
+      id: this.notificationChannel,
+      type: 'notification',
+      data: payload,
+    }
+    const frame = JSON.stringify(envelope)
+    subscribers.forEach((subscriber) => {
+      if (subscriber.readyState === WebSocket.OPEN) {
+        subscriber.send(frame)
+      }
+    })
+  }
+
+  ensureNotificationBridge() {
+    if (this.notificationBridgeDispose) {
+      return
+    }
+    this.notificationBridgeDispose = Util.registerPushListener((payload) => {
+      this.broadcastNotification(payload)
+    })
+  }
+
+  checkNotificationBridge() {
+    const subscribers = this.subscriptions.get(this.notificationChannel)
+    if ((!subscribers || subscribers.size === 0) && this.notificationBridgeDispose) {
+      try {
+        this.notificationBridgeDispose()
+      } catch (err) {
+        console.error('Failed to dispose notification bridge:', err)
+      }
+      this.notificationBridgeDispose = null
+    }
+  }
+
   async log_buffer(key, buf) {
 
     /*