pinokiod 3.150.0 → 3.152.0

package/kernel/router/common.js

@@ -11,6 +11,7 @@ class Common extends Processor {
       "headers": {
         "request": {
           "set": {
+            "Host": ["{http.request.host}"],
             "X-Forwarded-Proto": ["https"],
             "X-Forwarded-Host": ["{http.request.host}"]
           }

package/kernel/router/connector.js

@@ -16,6 +16,7 @@ class Connector extends Processor {
       "headers": {
         "request": {
           "set": {
+            "Host": ["{http.request.host}"],
             "X-Forwarded-Proto": ["{http.request.header.X-Forwarded-Proto}"],
             //"X-Forwarded-Proto": ["{http.request.scheme}"],
             //"X-Forwarded-Proto": ["https"],
@@ -55,6 +56,7 @@ class Connector extends Processor {
           "headers": {
             "request": {
               "set": {
+                "Host": ["{http.request.host}"],
                 //"X-Forwarded-Proto": ["https"],
                 //"Origin": "localhost",
                 "X-Forwarded-Proto": ["{http.request.scheme}"],

package/kernel/router/localhost_home_router.js

@@ -55,6 +55,7 @@ class LocalhostHomeRouter {
                       "headers": {
                         "request": {
                           "set": {
+                            "Host": ["{http.request.host}"],
                             "X-Forwarded-Proto": ["https"],
                             "X-Forwarded-Host": ["{http.request.host}"]
                           }

package/package.json

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

package/server/index.js

@@ -3190,61 +3190,180 @@ class Server {
     }
   }
   add_extra_urls(info) {
-    // get only the parts not from this peer
-    for(let host in this.kernel.peer.info) {
-      let host_info = this.kernel.peer.info[host]
+    if (!this.kernel.peer || !this.kernel.peer.info) {
+      return
+    }
 
-      let host_rewrites = host_info.rewrite_mapping
-      for(let key in host_rewrites) {
-        info.push({
-          online: true,
-          host: {
-            ip: host,
-            local: this.kernel.peer.host === host,
-            name: host_info.name,
-            platform: host_info.platform,
-            arch: host_info.arch
-          },
-          name: `[Files] ${host_rewrites[key].name}`,
-          ip: host_rewrites[key].external_ip
-        })
+    const ensureArray = (value) => {
+      if (!value) return []
+      return Array.isArray(value) ? value.filter(Boolean) : [value].filter(Boolean)
+    }
+
+    const normalizeHttpUrl = (value) => {
+      if (!value) return null
+      const str = String(value).trim()
+      if (!str) return null
+      if (/^https?:\/\//i.test(str)) {
+        return str.replace(/^https:/i, 'http:')
       }
-      if (this.kernel.peer.host !== host) {
-        let host_routers = host_info.router_info
-        for(let host_router of host_routers) {
-          let ip
-          // the peer sharing works only if external_ip is available (caddy is installed)
-          if (host_router.external_ip) {
-            ip = host_router.external_ip
-          } else {
-            // if caddy is not turned on, set ip as null, so that it suggests turning on peer sharing
-            ip = null
+      return `http://${str}`
+    }
+
+    const normalizeHttpsUrl = (value) => {
+      if (!value) return null
+      const str = String(value).trim()
+      if (!str) return null
+      if (/^https?:\/\//i.test(str)) {
+        return str.replace(/^http:/i, 'https:')
+      }
+      return `https://${str}`
+    }
+
+    const seen = new Set()
+
+    const pushEntry = ({ host, name, ip, httpUrl, httpsUrls, description, icon, online = true }) => {
+      const normalizedHttp = normalizeHttpUrl(httpUrl)
+      const hostNameForAlias = host && host.name ? String(host.name).trim() : ''
+      const peerSuffix = hostNameForAlias ? `.${hostNameForAlias}.localhost` : null
+
+      const normalizedHttpsSet = new Set(
+        ensureArray(httpsUrls)
+          .map(normalizeHttpsUrl)
+          .filter(Boolean)
+      )
+
+      if (host && host.local && peerSuffix) {
+        for (const originalUrl of normalizedHttpsSet) {
+          try {
+            const parsed = new URL(originalUrl)
+            if (parsed.hostname.endsWith(peerSuffix)) {
+              const aliasHost = `${parsed.hostname.slice(0, -peerSuffix.length)}.localhost`
+              if (aliasHost && aliasHost !== parsed.hostname) {
+                let pathname = parsed.pathname || ''
+                if (pathname === '/' || pathname === '') {
+                  pathname = ''
+                }
+                const aliasUrl = `${parsed.protocol}//${aliasHost}${pathname}${parsed.search}${parsed.hash}`
+                normalizedHttpsSet.add(aliasUrl)
+              }
+            }
+          } catch (_) {
+            // continue
           }
-          info.push({
-            online: true,
-            host: {
-              ip: host,
-              name: host_info.name,
-              platform: host_info.platform,
-              arch: host_info.arch
-            },
-            name: host_router.title || host_router.name,
-            ip
+        }
+      }
+
+      const normalizedHttps = Array.from(normalizedHttpsSet)
+      const ipValue = typeof ip === 'string' ? ip : (normalizedHttp ? normalizedHttp.replace(/^https?:\/\//i, '') : null)
+      const selectedUrl = normalizedHttps[0] || normalizedHttp || null
+      const protocol = normalizedHttps.length > 0 ? 'https' : (normalizedHttp ? 'http' : undefined)
+      const hostKey = host && (host.ip || host.name) ? `${host.ip || host.name}` : 'unknown'
+      const uniquenessKey = `${hostKey}|${name}|${ipValue || ''}|${selectedUrl || ''}`
+      if (seen.has(uniquenessKey)) {
+        return
+      }
+      seen.add(uniquenessKey)
+
+      const entry = {
+        online,
+        host: { ...host },
+        name,
+        ip: ipValue,
+        url: selectedUrl,
+        protocol,
+        urls: {
+          http: normalizedHttp,
+          https: normalizedHttps
+        }
+      }
+      if (description) {
+        entry.description = description
+      }
+      if (icon) {
+        entry.icon = icon
+      }
+      info.push(entry)
+    }
+
+    for (const host of Object.keys(this.kernel.peer.info)) {
+      const hostInfo = this.kernel.peer.info[host]
+      if (!hostInfo) {
+        continue
+      }
+
+      const hostMeta = {
+        ip: host,
+        local: this.kernel.peer.host === host,
+        name: hostInfo.name,
+        platform: hostInfo.platform,
+        arch: hostInfo.arch
+      }
+
+      const rewrites = hostInfo.rewrite_mapping
+      if (rewrites && typeof rewrites === 'object') {
+        for (const key of Object.keys(rewrites)) {
+          const rewrite = rewrites[key]
+          if (!rewrite) {
+            continue
+          }
+          const externalIp = Array.isArray(rewrite.external_ip) ? rewrite.external_ip[0] : rewrite.external_ip
+          const httpsSources = [
+            ...ensureArray(rewrite.external_router),
+            ...ensureArray(rewrite.internal_router)
+          ]
+          pushEntry({
+            host: hostMeta,
+            name: `[Files] ${rewrite.name || key}`,
+            ip: externalIp || null,
+            httpUrl: externalIp,
+            httpsUrls: Array.from(new Set(httpsSources))
           })
         }
       }
 
-      for(let app of host_info.installed) {
-        info.push({
-          host: {
-            ip: host,
-            local: this.kernel.peer.host === host,
-            name: host_info.name,
-            platform: host_info.platform,
-            arch: host_info.arch
-          },
-          name: app.title || app.folder,
-          ip: app.http_href.replace("http://", "")
+      const hostRouters = Array.isArray(hostInfo.router_info) ? hostInfo.router_info : []
+      for (const route of hostRouters) {
+        if (!route) {
+          continue
+        }
+        const externalIp = Array.isArray(route.external_ip) ? route.external_ip[0] : route.external_ip
+        const httpUrl = externalIp || null
+        const httpsCandidates = Array.from(new Set([
+          ...ensureArray(route.external_router),
+          ...ensureArray(route.internal_router)
+        ]))
+        if (httpsCandidates.length === 0 && !httpUrl) {
+          continue
+        }
+        pushEntry({
+          host: hostMeta,
+          name: route.title || route.name,
+          ip: externalIp || null,
+          httpUrl,
+          httpsUrls: httpsCandidates,
+          description: route.description,
+          icon: route.icon || route.https_icon || route.http_icon
+        })
+      }
+
+      const installedApps = Array.isArray(hostInfo.installed) ? hostInfo.installed : []
+      for (const app of installedApps) {
+        if (!app) {
+          continue
+        }
+        const httpHref = Array.isArray(app.http_href) ? app.http_href[0] : app.http_href
+        const httpsCandidates = Array.from(new Set([
+          ...ensureArray(app.app_href),
+          ...ensureArray(app.https_href)
+        ]))
+        pushEntry({
+          host: hostMeta,
+          name: app.title || app.name || app.folder,
+          ip: httpHref ? httpHref.replace(/^https?:\/\//i, '') : null,
+          httpUrl: httpHref || null,
+          httpsUrls: httpsCandidates,
+          description: app.description,
+          icon: app.https_icon || app.http_icon || app.icon
         })
       }
     }
@@ -6623,6 +6742,7 @@ class Server {
         if (preferHttps) {
           httpsHosts = resolveHttpsHosts(item)
         }
+        console.log("httpsHosts", httpsHosts)
         const httpsUrls = httpsHosts.map((host) => {
           if (!host) {
             return null
@@ -6633,6 +6753,7 @@ class Server {
           }
           return `https://${trimmed}`
         }).filter(Boolean)
+        console.log("httpsUrls", httpsUrls)
 
         const preferredHttpsUrl = preferFriendlyHost(httpsHosts)
         const displayHttpsUrl = preferredHttpsUrl
@@ -6661,7 +6782,7 @@ class Server {
         }
       })
 
-//      this.add_extra_urls(info)
+      this.add_extra_urls(info)
       res.json({
         info
       })

package/server/public/urldropdown.css

@@ -97,6 +97,65 @@ body.dark .url-dropdown-name {
 body.dark .url-dropdown-url {
   color: #a0aec0;
 }
+.url-dropdown-url-list {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+}
+.url-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 4px 8px;
+  border-radius: 6px;
+  border: 1px solid #e2e8f0;
+  background: #f8fafc;
+  color: #2d3748;
+  font-size: 12px;
+  font-weight: 500;
+  cursor: pointer;
+  transition: background 0.15s ease, border-color 0.15s ease;
+}
+.url-chip:hover {
+  background: #edf2f7;
+  border-color: #cbd5f5;
+}
+body.dark .url-chip {
+  border-color: rgba(255,255,255,0.15);
+  background: rgba(255,255,255,0.06);
+  color: #e2e8f0;
+}
+body.dark .url-chip:hover {
+  background: rgba(255,255,255,0.1);
+  border-color: rgba(255,255,255,0.22);
+}
+.url-chip .chip-mark {
+  font-size: 10px;
+  font-weight: 600;
+  letter-spacing: 0.05em;
+  text-transform: uppercase;
+  padding: 2px 4px;
+  border-radius: 4px;
+}
+.url-chip-https .chip-mark {
+  background: rgba(72, 187, 120, 0.18);
+  color: #276749;
+}
+body.dark .url-chip-https .chip-mark {
+  background: rgba(72, 187, 120, 0.25);
+  color: #9ae6b4;
+}
+.url-chip-http .chip-mark {
+  background: rgba(237, 137, 54, 0.18);
+  color: #9c4221;
+}
+body.dark .url-chip-http .chip-mark {
+  background: rgba(237, 137, 54, 0.25);
+  color: #fbd38d;
+}
+.url-chip .chip-label {
+  font-weight: 500;
+}
 .url-dropdown-loading {
   padding: 12px 16px;
   font-size: 14px;

package/server/public/urldropdown.js

@@ -122,6 +122,84 @@ function initUrlDropdown(config = {}) {
     return Array.from(urls);
   };
 
+  const ensureContainerHref = (value) => {
+    if (!value || typeof value !== 'string') {
+      return value;
+    }
+    if (value.startsWith('/container?url=')) {
+      return value;
+    }
+    return `/container?url=${encodeURIComponent(value)}`;
+  };
+
+  const openUrlWithType = (url, type) => {
+    if (!url) {
+      return;
+    }
+    if (!type || type === 'current') {
+      location.href = url;
+      return;
+    }
+    const target = ensureContainerHref(url);
+    location.href = target;
+  };
+
+  const escapeAttribute = (value) => {
+    if (value === null || value === undefined) {
+      return '';
+    }
+    return String(value)
+      .replace(/&/g, '&')
+      .replace(/"/g, '"')
+      .replace(/'/g, ''')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;');
+  };
+
+  const formatUrlLabel = (url) => {
+    if (!url) {
+      return '';
+    }
+    return url.replace(/^https?:\/\//i, '');
+  };
+
+  const createUrlChip = (url, type, scheme) => {
+    if (!url) {
+      return '';
+    }
+    const normalizedType = type || 'remote';
+    const classSuffix = scheme === 'HTTPS' ? 'https' : 'http';
+    const label = formatUrlLabel(url);
+    return `
+      <button type="button" class="url-chip url-chip-${classSuffix}" data-url="${escapeAttribute(url)}" data-host-type="${escapeAttribute(normalizedType)}">
+        <span class="chip-mark">${scheme}</span>
+        <span class="chip-label">${escapeHtml(label)}</span>
+      </button>
+    `;
+  };
+
+  const buildProcessUrlList = (process) => {
+    const { httpUrl, httpsUrls } = getProcessUrls(process);
+    const hostType = (process && process.host && process.host.local) ? 'local' : 'remote';
+    const parts = [];
+    const seen = new Set();
+    httpsUrls.forEach((candidate) => {
+      if (!candidate || seen.has(candidate)) {
+        return;
+      }
+      parts.push(createUrlChip(candidate, hostType, 'HTTPS'));
+      seen.add(candidate);
+    });
+    if (httpUrl && !seen.has(httpUrl)) {
+      parts.push(createUrlChip(httpUrl, hostType, 'HTTP'));
+      seen.add(httpUrl);
+    }
+    if (parts.length === 0) {
+      return '';
+    }
+    return `<div class="url-dropdown-url-list">${parts.join('')}</div>`;
+  };
+
   let isDropdownVisible = false;
   let allProcesses = []; // Store all processes for filtering
   let filteredProcesses = []; // Store currently filtered processes
@@ -164,26 +242,16 @@ function initUrlDropdown(config = {}) {
 
   if (document.querySelector(".urlbar")) {
     document.querySelector(".urlbar").addEventListener("submit", (e) => {
-      e.preventDefault()
-      e.stopPropagation()
-      let el = e.target.querySelector("input[type=url]")
-      let val = el.value
-      let type = el.getAttribute("data-host-type")
-      if (type === "local") {
-        let redirect_uri = "/container?url=" + val
-        location.href = redirect_uri
-      } else {
-        let u = new URL(val)
-        if (String(u.port) === "42000") {
-          // pinokio app => open the url itself
-          window.open(val, "_blank", 'self')
-        } else {
-          // other servers => open in pinokio redirect frame
-          let redirect_uri = "/container?url=" + val
-          location.href = redirect_uri
-        }
+      e.preventDefault();
+      e.stopPropagation();
+      const el = e.target.querySelector("input[type=url]");
+      if (!el) {
+        return;
       }
-    })
+      const val = el.value;
+      const type = el.getAttribute("data-host-type");
+      openUrlWithType(val, type);
+    });
   }
 
 
@@ -391,7 +459,7 @@ function initUrlDropdown(config = {}) {
         <div class="url-dropdown-host-header current-tab">
           <span class="host-name">Current tab</span>
         </div>
-        <div class="url-dropdown-item" data-url="${escapeHtml(currentUrl)}" data-host-type="current">
+        <div class="url-dropdown-item" data-url="${escapeAttribute(currentUrl)}" data-host-type="current">
           <div class="url-dropdown-name">
             <span>
               <i class="fa-solid fa-clone"></i>
@@ -407,32 +475,7 @@ function initUrlDropdown(config = {}) {
       html += createEmptyStateHtml(getEmptyStateMessage(urlInput));
       dropdown.innerHTML = html;
       attachCreateButtonHandler(dropdown, urlInput);
-      dropdown.querySelectorAll('.url-dropdown-item:not(.non-selectable)').forEach(item => {
-        item.addEventListener('click', function() {
-          const url = this.getAttribute('data-url');
-          const type = this.getAttribute('data-host-type');
-          urlInput.value = url;
-          urlInput.setAttribute("data-host-type", type || 'current');
-          hideDropdown();
-
-          if (type === "local") {
-            let redirect_uri = "/container?url=" + url;
-            location.href = redirect_uri;
-          } else {
-            if (!type || type === 'current') {
-              location.href = url;
-              return;
-            }
-            let u = new URL(url);
-            if (String(u.port) === "42000") {
-              window.open(url, "_blank", 'self');
-            } else {
-              let redirect_uri = "/container?url=" + url;
-              location.href = redirect_uri;
-            }
-          }
-        });
-      });
+      attachUrlItemHandlers(dropdown);
       return;
     }
 
@@ -442,14 +485,14 @@ function initUrlDropdown(config = {}) {
     Object.keys(groupedProcesses).forEach(hostKey => {
       const hostData = groupedProcesses[hostKey];
       const hostInfo = hostData.host;
-      const processes = hostData.processes;
+      const hostProcesses = hostData.processes;
       const isLocal = hostData.isLocal;
       
       // Add host header
       html += createHostHeader(hostInfo, isLocal);
       
       // Add processes for this host
-      processes.forEach(process => {
+      hostProcesses.forEach(process => {
         const onlineIndicator = process.online ? 
           '<div class="status-circle online"></div>' : 
           '<div class="status-circle offline"></div>';
@@ -461,63 +504,70 @@ function initUrlDropdown(config = {}) {
             <div class="url-dropdown-item non-selectable">
               <div class="url-dropdown-name">
                 ${onlineIndicator}
-                <button class="peer-network-button" data-network-url="${networkUrl}"><i class="fa-solid fa-toggle-on"></i> Turn on peer network</button>
-                ${escapeHtml(process.name)}
-              </div>
-            </div>
-          `;
-        } else {
-          // Normal selectable item
-          const url = getProcessDisplayUrl(process);
-          if (!url) {
-            return;
-          }
-          html += `
-            <div class="url-dropdown-item" data-url="${url}" data-host-type="${process.host.local ? "local" : "remote"}">
-              <div class="url-dropdown-name">
-                ${onlineIndicator}
+                <button class="peer-network-button" data-network-url="${escapeAttribute(networkUrl)}"><i class="fa-solid fa-toggle-on"></i> Turn on peer network</button>
                 ${escapeHtml(process.name)}
               </div>
-              <div class="url-dropdown-url">${escapeHtml(url)}</div>
             </div>
           `;
+          return;
         }
+
+        const displayUrl = getProcessDisplayUrl(process);
+        if (!displayUrl) {
+          return;
+        }
+        const selectionType = (process.host && process.host.local) ? 'local' : 'remote';
+        const urlListHtml = buildProcessUrlList(process);
+        html += `
+          <div class="url-dropdown-item" data-url="${escapeAttribute(displayUrl)}" data-host-type="${escapeAttribute(selectionType)}">
+            <div class="url-dropdown-name">
+              ${onlineIndicator}
+              ${escapeHtml(process.name)}
+            </div>
+            <div class="url-dropdown-url">${escapeHtml(displayUrl)}</div>
+            ${urlListHtml}
+          </div>
+        `;
       });
     });
 
     dropdown.innerHTML = html;
+    attachUrlItemHandlers(dropdown);
+  }
+
+  function handleSelection(url, type, options = {}) {
+    if (!url) return;
+    if (urlInput && options.updateInput !== false) {
+      urlInput.value = url;
+      urlInput.setAttribute('data-host-type', type || 'remote');
+    }
+    hideDropdown();
+    if (options.navigate === false) {
+      return;
+    }
+    openUrlWithType(url, type);
+  }
 
-    // Add click handlers to dropdown items
-    dropdown.querySelectorAll('.url-dropdown-item:not(.non-selectable)').forEach(item => {
+  function attachUrlItemHandlers(container) {
+    if (!container) return;
+    container.querySelectorAll('.url-dropdown-item:not(.non-selectable)').forEach(item => {
       item.addEventListener('click', function() {
         const url = this.getAttribute('data-url');
         const type = this.getAttribute('data-host-type');
-        urlInput.value = url;
-        urlInput.setAttribute("data-host-type", type || 'remote');
-        hideDropdown();
-        
-        // Navigate directly instead of dispatching submit event
-        if (type === "local") {
-          let redirect_uri = "/container?url=" + url;
-          location.href = redirect_uri;
-        } else if (type === 'current') {
-          location.href = url;
-        } else {
-          let u = new URL(url);
-          if (String(u.port) === "42000") {
-            window.open(url, "_blank", 'self');
-          } else {
-            let redirect_uri = "/container?url=" + url;
-            location.href = redirect_uri;
-          }
-        }
+        handleSelection(url, type);
       });
     });
-
-    // Add click handlers to peer network buttons
-    dropdown.querySelectorAll('.peer-network-button').forEach(button => {
-      button.addEventListener('click', function(e) {
-        e.stopPropagation();
+    container.querySelectorAll('.url-chip').forEach(button => {
+      button.addEventListener('click', function(event) {
+        event.stopPropagation();
+        const url = this.getAttribute('data-url');
+        const type = this.getAttribute('data-host-type');
+        handleSelection(url, type);
+      });
+    });
+    container.querySelectorAll('.peer-network-button').forEach(button => {
+      button.addEventListener('click', function(event) {
+        event.stopPropagation();
         const networkUrl = this.getAttribute('data-network-url');
         window.open(networkUrl, '_blank', 'self');
       });

package/server/views/net.ejs

@@ -704,10 +704,9 @@ document.addEventListener('DOMContentLoaded', function() {
                         <% item.external_router.forEach((domain) => { %>
                             <a class='net' target="_blank" href="https://<%=domain%>"><span class='mark'>HTTPS</span><span><%=domain%></span></a>
                         <% }) %>
-                      <% } else { %>
-                        <% if (item.external_ip) { %>
-                          <a class='net' target="_blank" href="http://<%=item.external_ip%>"><span class='mark'>HTTP</span><span><%=item.external_ip%></span></a>
-                        <% } %>
+                      <% } %>
+                      <% if (item.external_ip) { %>
+                        <a class='net' target="_blank" href="http://<%=item.external_ip%>"><span class='mark'>HTTP</span><span><%=item.external_ip%></span></a>
                       <% } %>
                     </div>
                   </div>