pinokiod 7.1.66 → 7.1.68

package/package.json

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

package/server/index.js

@@ -5480,43 +5480,53 @@ class Server {
     return list
   }
   async check_router_up() {
-    // check if caddy is runnign properly
-    //    try https://pinokio.localhost
-    //    if it works, proceed
-    //    if not, redirect
-    let https_running = false
+    let response
+    let config
     try {
       let res = await axios.get(`http://127.0.0.1:2019/config/`, {
         timeout: 2000
       })
-      let test = /pinokio\.localhost/.test(JSON.stringify(res.data))
-      if (test) {
-        https_running = true
-      }
+      config = res.data
     } catch (e) {
-//      console.log(e)
-    }
-//    console.log({ https_running })
-    if (!https_running) {
-      return { error: "pinokio.host not yet available" }
+      response = {
+        stage: "caddy_admin_unavailable",
+        error: "caddy admin unavailable",
+        detail: e && e.message ? e.message : String(e)
+      }
     }
-
-
-    // check if pinokio.localhost router is running
-    let router_running = false
-    let router = this.kernel.router.published()
-    for(let ip in router) {
-      let domains = router[ip]
-      if (domains.includes("pinokio.localhost")) {
-        router_running = true
-        break
+    if (!response) {
+      if (config === null || typeof config === "undefined") {
+        response = {
+          stage: "caddy_config_empty",
+          error: "caddy config not yet loaded"
+        }
+      } else if (!/pinokio\.localhost/.test(JSON.stringify(config))) {
+        response = {
+          stage: "caddy_route_missing",
+          error: "pinokio.localhost missing from caddy config"
+        }
+      } else {
+        let router_running = false
+        let router = this.kernel.router.published()
+        for (let ip in router) {
+          let domains = router[ip]
+          if (domains.includes("pinokio.localhost")) {
+            router_running = true
+            break
+          }
+        }
+        if (!router_running) {
+          response = {
+            stage: "pinokio_router_missing",
+            error: "pinokio.localhost not yet published by Pinokio router"
+          }
+        }
       }
     }
-    if (!router_running) {
-      return { error: "pinokio.localhost not yet available" }
+    if (!response) {
+      response = { success: true, stage: "ready" }
     }
-
-    return { success: true }
+    return response
   }
   async start(options) {
     this.debug = false
@@ -11428,37 +11438,8 @@ class Server {
         return
       }
 
-      let https_running = false
-      try {
-        let res = await axios.get(`http://127.0.0.1:2019/config/`, {
-          timeout: 2000
-        })
-        let test = /pinokio\.localhost/.test(JSON.stringify(res.data))
-        if (test) {
-          https_running = true
-        }
-      } catch (e) {
-        console.log(e)
-      }
-      if (!https_running) {
-//        res.json({ error: "pinokio.host not yet available" })
-        res.redirect("/setup/connect?callback=/connect/" + req.params.provider)
-        return
-      }
-
-
-      // check if pinokio.localhost router is running
-      let router_running = false
-      let router = this.kernel.router.published()
-      for(let ip in router) {
-        let domains = router[ip]
-        if (domains.includes("pinokio.localhost")) {
-          router_running = true
-          break
-        }
-      }
-      if (!router_running) {
-//        res.json({ error: "pinokio.localhost not yet available" })
+      const routerStatus = await this.check_router_up()
+      if (!routerStatus.success) {
         res.redirect("/setup/connect?callback=/connect/" + req.params.provider)
         return
       }
@@ -15576,6 +15557,13 @@ class Server {
           server_ready: true,
           phase: this.getStartupStatus().phase === "idle" ? "ready" : this.getStartupStatus().phase
         })
+        if (this.kernel && this.kernel.peer && this.kernel.peer.https_active) {
+          this.kernel.refresh(true).then(() => {
+            return this.check_router_up()
+          }).catch((error) => {
+            console.warn("[Pinokiod] initial secure router refresh failed", error && error.message ? error.message : error)
+          })
+        }
         resolve()
       });
       this.httpTerminator = createHttpTerminator({

package/server/views/connect/index.ejs

@@ -49,11 +49,6 @@
             color-scheme: light;
         }
 
-        body[data-page="connect"][data-agent="electron"] {
-            padding-top: 26px;
-            box-sizing: border-box;
-        }
-
         @media (prefers-color-scheme: dark) {
             body[data-page="connect"] {
                 --connect-body-bg: #010617;
@@ -558,10 +553,8 @@
         const name = "<%=name%>"
         const SECURE_CONNECT_POLL_INTERVAL = 2000
         const SECURE_CONNECT_TIMEOUT = 120000
-        const SECURE_CONNECT_BROWSER_RETRY_DELAY = 1200
         let secureConnectPollTimer = null
         let secureConnectTimeoutHandle = null
-        let secureConnectBrowserRetryHandle = null
 
         function generateRandomString(length) {
             const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
@@ -593,21 +586,6 @@
                 .replace(/=/g, '');
         }
 
-        async function openAuthInBrowser(authUrl) {
-            const response = await fetch('/go', {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ url: authUrl })
-            });
-            if (!response.ok) {
-                throw new Error(`Browser launch failed with status ${response.status}`);
-            }
-            const payload = await response.json().catch(() => ({}));
-            if (payload && payload.error) {
-                throw new Error(payload.error);
-            }
-        }
-
         // OAuth functions
         async function login() {
             try {
@@ -641,24 +619,10 @@
                     startSecureConnectPolling();
                     setStatus(`Continue the ${name} login in your browser.`, 'warning');
                     try {
-                        if (secureConnectBrowserRetryHandle) {
-                            clearTimeout(secureConnectBrowserRetryHandle);
-                            secureConnectBrowserRetryHandle = null;
-                        }
-                        await openAuthInBrowser(authUrl);
-                        secureConnectBrowserRetryHandle = setTimeout(async () => {
-                            secureConnectBrowserRetryHandle = null;
-                            try {
-                                const token = await ensureValidToken();
-                                if (!token && document.visibilityState === 'visible' && document.hasFocus()) {
-                                    await openAuthInBrowser(authUrl);
-                                }
-                            } catch (retryError) {
-                                console.warn('Retry browser launch failed:', retryError);
-                            }
-                        }, SECURE_CONNECT_BROWSER_RETRY_DELAY);
+                        window.open(authUrl, '_blank', 'browser');
                     } catch (openError) {
-                        stopSecureConnectPolling(`Could not open the browser automatically. Please open ${authUrl} manually.`, 'error');
+                        hideLoader();
+                        setStatus(`Could not open the browser. Please open ${authUrl} manually.`, 'error');
                         return;
                     }
                     return;
@@ -684,10 +648,6 @@
                 clearTimeout(secureConnectTimeoutHandle);
                 secureConnectTimeoutHandle = null;
             }
-            if (secureConnectBrowserRetryHandle) {
-                clearTimeout(secureConnectBrowserRetryHandle);
-                secureConnectBrowserRetryHandle = null;
-            }
             if (message) {
                 hideLoader();
                 setStatus(message, type);
@@ -866,15 +826,12 @@
 
         function startHttpConnect() {
             stopConnectPolling()
-            showLoader('Connecting... Complete the login in the secure window.', {
+            showLoader(`Connecting... Complete the login in the ${CONNECT_AGENT === 'electron' ? 'browser' : 'secure window'}.`, {
                 cancellable: true,
                 onCancel: () => stopConnectPolling('Connection cancelled.', 'warning')
             })
             setStatus('Waiting for connection...', 'warning')
-            const secureWindow = window.open(SECURE_CONNECT_URL, '_blank')
-            if (!secureWindow) {
-                setStatus('Could not open the secure window. Please allow pop-ups or open https://pinokio.localhost/connect/<%=name%> manually.', 'error')
-            }
+            window.open(SECURE_CONNECT_URL, '_blank', 'browser')
             pollConnectStatus()
             connectPollTimer = setInterval(pollConnectStatus, CONNECT_POLL_INTERVAL)
             connectTimeoutHandle = setTimeout(() => {

package/server/views/setup.ejs

@@ -243,6 +243,12 @@ document.addEventListener("DOMContentLoaded", async () => {
     const waitRoot = document.querySelector(".requirements .content")
     const waitLabel = document.querySelector(".requirements .content .loading span")
     const WAIT_TIMEOUT_MS = 120000
+    const ROUTER_STAGE_MESSAGES = {
+      caddy_admin_unavailable: "Restarting Pinokio... (waiting for Caddy)",
+      caddy_config_empty: "Restarting Pinokio... (publishing secure router)",
+      caddy_route_missing: "Restarting Pinokio... (loading pinokio.localhost)",
+      pinokio_router_missing: "Restarting Pinokio... (waiting for Pinokio router)"
+    }
     const setWaitLabel = (message) => {
       if (waitLabel) {
         waitLabel.textContent = message
@@ -314,10 +320,13 @@ document.addEventListener("DOMContentLoaded", async () => {
               lastKnownError = startupStatus.error
             }
             if (startupStatus && startupStatus.phase) {
-              lastKnownPhase = startupStatus.phase
-              const phaseMessage = startupStatus.phase === "ready"
+              lastKnownPhase = (routerStatus && routerStatus.stage) || startupStatus.phase
+              const routerStageMessage = routerStatus && routerStatus.stage
+                ? ROUTER_STAGE_MESSAGES[routerStatus.stage]
+                : null
+              const phaseMessage = routerStageMessage || (startupStatus.phase === "ready"
                 ? "Secure router is almost ready..."
-                : `Restarting Pinokio... (${startupStatus.phase.replace(/_/g, " ")})`
+                : `Restarting Pinokio... (${startupStatus.phase.replace(/_/g, " ")})`)
               setWaitLabel(phaseMessage)
             }