pinokiod 7.1.68 → 7.1.69

package/package.json

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

package/server/index.js

@@ -5480,53 +5480,80 @@ class Server {
     return list
   }
   async check_router_up() {
-    let response
-    let config
+    // check if caddy is runnign properly
+    //    try https://pinokio.localhost
+    //    if it works, proceed
+    //    if not, redirect
+    let https_running = false
     try {
       let res = await axios.get(`http://127.0.0.1:2019/config/`, {
         timeout: 2000
       })
-      config = res.data
-    } catch (e) {
-      response = {
-        stage: "caddy_admin_unavailable",
-        error: "caddy admin unavailable",
-        detail: e && e.message ? e.message : String(e)
+      let test = /pinokio\.localhost/.test(JSON.stringify(res.data))
+      if (test) {
+        https_running = true
       }
+    } catch (e) {
+      return { error: "caddy admin unavailable" }
     }
-    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"
-          }
-        }
+//    console.log({ https_running })
+    if (!https_running) {
+      return { error: "pinokio.host not yet available" }
+    }
+
+    // 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) {
-      response = { success: true, stage: "ready" }
+    if (!router_running) {
+      return { error: "pinokio.localhost not yet available" }
     }
-    return response
+
+    return { success: true }
+  }
+  async ensureSecureRouterReady(timeout = 120000, interval = 500) {
+    if (!(this.kernel && this.kernel.peer && this.kernel.peer.https_active)) {
+      return { success: true, stage: "disabled" }
+    }
+    const caddy = this.kernel && this.kernel.bin && this.kernel.bin.mod
+      ? this.kernel.bin.mod.caddy
+      : null
+    const deadline = Date.now() + timeout
+    let startedCaddyManually = false
+    let refreshedRouter = false
+    let lastStatus = null
+    while (Date.now() < deadline) {
+      lastStatus = await this.check_router_up()
+      if (lastStatus && lastStatus.success) {
+        return lastStatus
+      }
+      if (
+        lastStatus &&
+        lastStatus.error === "caddy admin unavailable" &&
+        !startedCaddyManually &&
+        caddy &&
+        typeof caddy.start === "function"
+      ) {
+        startedCaddyManually = true
+        await caddy.start()
+        continue
+      }
+      if (!refreshedRouter) {
+        refreshedRouter = true
+        await this.kernel.refresh(true).catch(() => {})
+        continue
+      }
+      await new Promise((resolve) => {
+        setTimeout(resolve, interval)
+      })
+    }
+    throw new Error(lastStatus && lastStatus.error ? lastStatus.error : "secure router did not come up")
   }
   async start(options) {
     this.debug = false
@@ -5797,6 +5824,12 @@ class Server {
           phase: "initializing_environment"
         })
         await Environment.init({}, this.kernel)
+        if (this.kernel && this.kernel.peer && this.kernel.peer.https_active) {
+          setStartupStatus({
+            phase: "waiting_for_secure_router"
+          })
+          await this.ensureSecureRouterReady()
+        }
         setStartupStatus({
           sys_ready: this.getStartupStatus().sys_ready,
           managed_ready: true,
@@ -11438,8 +11471,36 @@ class Server {
         return
       }
 
-      const routerStatus = await this.check_router_up()
-      if (!routerStatus.success) {
+      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" })
         res.redirect("/setup/connect?callback=/connect/" + req.params.provider)
         return
       }
@@ -15557,13 +15618,6 @@ 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/setup.ejs

@@ -243,17 +243,76 @@ 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 WAIT_DEBUG_HISTORY_LIMIT = 12
+    const waitDebugState = {
+      events: [],
+      phase: null,
+      router: null,
+      startupError: null,
     }
     const setWaitLabel = (message) => {
       if (waitLabel) {
         waitLabel.textContent = message
       }
     }
+    const pushWaitDebugEvent = (message) => {
+      const timestamp = new Date().toLocaleTimeString()
+      const entry = `[${timestamp}] ${message}`
+      if (waitDebugState.events[waitDebugState.events.length - 1] !== entry) {
+        waitDebugState.events.push(entry)
+        if (waitDebugState.events.length > WAIT_DEBUG_HISTORY_LIMIT) {
+          waitDebugState.events.shift()
+        }
+      }
+    }
+    const ensureWaitDebugPanel = () => {
+      if (!waitRoot) {
+        return null
+      }
+      let panel = waitRoot.querySelector(".wait-debug")
+      if (!panel) {
+        panel = document.createElement("div")
+        panel.className = "wait-debug"
+        panel.style.marginTop = "16px"
+        panel.style.padding = "12px"
+        panel.style.border = "1px solid rgba(255,255,255,0.12)"
+        panel.style.borderRadius = "8px"
+        panel.style.background = "rgba(255,255,255,0.04)"
+        panel.style.textAlign = "left"
+        panel.innerHTML = `
+          <div style="font-size:12px;font-weight:600;letter-spacing:0.04em;text-transform:uppercase;opacity:0.75;margin-bottom:8px;">Debug</div>
+          <pre class="wait-debug-body" style="margin:0;text-align:left;white-space:pre-wrap;word-break:break-word;font-size:12px;line-height:1.5;opacity:0.9;"></pre>
+        `
+        waitRoot.appendChild(panel)
+      }
+      return panel.querySelector(".wait-debug-body")
+    }
+    const renderWaitDebug = ({ startedAt, routerStatus, startupStatus } = {}) => {
+      const body = ensureWaitDebugPanel()
+      if (!body) {
+        return
+      }
+      const elapsedSeconds = startedAt ? Math.max(0, Math.floor((Date.now() - startedAt) / 1000)) : 0
+      const lines = [
+        `Elapsed: ${elapsedSeconds}s`,
+        `Startup phase: ${startupStatus && startupStatus.phase ? startupStatus.phase : "-"}`,
+        `Startup error: ${startupStatus && startupStatus.error ? startupStatus.error : "-"}`,
+        `Router check: ${routerStatus ? JSON.stringify(routerStatus) : "-"}`,
+        `Startup payload: ${startupStatus ? JSON.stringify({
+          phase: startupStatus.phase || null,
+          error: startupStatus.error || null,
+          startup_pending: startupStatus.startup_pending,
+          requirements_pending: startupStatus.requirements_pending,
+          updated_at: startupStatus.updated_at || null
+        }) : "-"}`,
+      ]
+      if (waitDebugState.events.length > 0) {
+        lines.push("")
+        lines.push("Recent events:")
+        lines.push(...waitDebugState.events)
+      }
+      body.textContent = lines.join("\n")
+    }
     const showWaitError = (message) => {
       if (waitRoot) {
         waitRoot.innerHTML = `
@@ -265,6 +324,7 @@ document.addEventListener("DOMContentLoaded", async () => {
             <a class='btn' href='${location.href}'>Retry</a>
           </div>
         `
+        renderWaitDebug()
       } else {
         alert(message)
       }
@@ -272,6 +332,8 @@ document.addEventListener("DOMContentLoaded", async () => {
 
     try {
       setWaitLabel("Enabling secure localhost access...")
+      pushWaitDebugEvent("saving secure localhost flags")
+      renderWaitDebug()
       const networkResponse = await fetch("/network", {
         method: "post",
         headers: { "Content-Type": "application/json" },
@@ -285,8 +347,12 @@ document.addEventListener("DOMContentLoaded", async () => {
       if (networkResponse && networkResponse.error) {
         throw new Error(networkResponse.error)
       }
+      pushWaitDebugEvent("secure localhost flags saved")
+      renderWaitDebug()
 
       setWaitLabel("Restarting Pinokio...")
+      pushWaitDebugEvent("restart requested")
+      renderWaitDebug()
       try {
         await fetch("/restart", {
           method: "post"
@@ -298,6 +364,7 @@ document.addEventListener("DOMContentLoaded", async () => {
       const startedAt = Date.now()
       let lastKnownError = null
       let lastKnownPhase = null
+      renderWaitDebug({ startedAt })
 
       await new Promise((resolve, reject) => {
         const interval = setInterval(async () => {
@@ -319,16 +386,29 @@ document.addEventListener("DOMContentLoaded", async () => {
             if (startupStatus && startupStatus.error) {
               lastKnownError = startupStatus.error
             }
+            if (startupStatus && startupStatus.phase && startupStatus.phase !== waitDebugState.phase) {
+              waitDebugState.phase = startupStatus.phase
+              pushWaitDebugEvent(`phase -> ${startupStatus.phase}`)
+            }
+            const routerSummary = routerStatus
+              ? (routerStatus.success ? "success" : (routerStatus.error || JSON.stringify(routerStatus)))
+              : null
+            if (routerSummary && routerSummary !== waitDebugState.router) {
+              waitDebugState.router = routerSummary
+              pushWaitDebugEvent(`router -> ${routerSummary}`)
+            }
+            if (startupStatus && startupStatus.error && startupStatus.error !== waitDebugState.startupError) {
+              waitDebugState.startupError = startupStatus.error
+              pushWaitDebugEvent(`startup error -> ${startupStatus.error}`)
+            }
             if (startupStatus && startupStatus.phase) {
-              lastKnownPhase = (routerStatus && routerStatus.stage) || startupStatus.phase
-              const routerStageMessage = routerStatus && routerStatus.stage
-                ? ROUTER_STAGE_MESSAGES[routerStatus.stage]
-                : null
-              const phaseMessage = routerStageMessage || (startupStatus.phase === "ready"
+              lastKnownPhase = startupStatus.phase
+              const phaseMessage = startupStatus.phase === "ready"
                 ? "Secure router is almost ready..."
-                : `Restarting Pinokio... (${startupStatus.phase.replace(/_/g, " ")})`)
+                : `Restarting Pinokio... (${startupStatus.phase.replace(/_/g, " ")})`
               setWaitLabel(phaseMessage)
             }
+            renderWaitDebug({ startedAt, routerStatus, startupStatus })
 
             if (startupStatus && startupStatus.phase === "error") {
               clearInterval(interval)
@@ -339,10 +419,14 @@ document.addEventListener("DOMContentLoaded", async () => {
             if ((Date.now() - startedAt) >= WAIT_TIMEOUT_MS) {
               clearInterval(interval)
               const detail = lastKnownError || lastKnownPhase || "secure localhost router did not come up"
+              pushWaitDebugEvent(`timeout -> ${detail}`)
+              renderWaitDebug({ startedAt, routerStatus, startupStatus })
               reject(new Error(`Timed out waiting for restart: ${detail}`))
             }
           } catch (error) {
             lastKnownError = error && error.message ? error.message : String(error)
+            pushWaitDebugEvent(`poll error -> ${lastKnownError}`)
+            renderWaitDebug({ startedAt })
             if ((Date.now() - startedAt) >= WAIT_TIMEOUT_MS) {
               clearInterval(interval)
               reject(new Error(`Timed out waiting for restart: ${lastKnownError}`))