pinokiod 7.1.70 → 7.1.71

package/kernel/bin/caddy.js

@@ -79,12 +79,23 @@ class Caddy {
     console.log("Caddy Installed?", installed)
     if (installed) {
       let resolved
+      let startup_output = []
+      this.kernel.caddy_startup_output = startup_output
       await new Promise((resolve, reject) => {
         this.kernel.exec({
           message: `caddy run --watch`,
           path: this.kernel.homedir,
         }, (e) => {
           process.stdout.write(e.raw)
+          const cleaned = e && e.cleaned ? e.cleaned : ""
+          const lines = cleaned.split(/\r?\n/).map((line) => line.trim()).filter(Boolean)
+          for (let line of lines) {
+            startup_output.push(line)
+            if (startup_output.length > 20) {
+              startup_output.shift()
+            }
+          }
+          this.kernel.caddy_startup_output = startup_output.slice()
           if (!resolved) {
             if (/endpoint started/i.test(e.cleaned)) {
               resolved = true
@@ -93,6 +104,28 @@ class Caddy {
           }
         })
       })
+      let admin_running = false
+      const admin_wait_started = Date.now()
+      while ((Date.now() - admin_wait_started) < 5000) {
+        admin_running = await this.running()
+        if (admin_running) {
+          break
+        }
+        await new Promise((resolve) => {
+          setTimeout(resolve, 250)
+        })
+      }
+      if (!admin_running) {
+        console.log("caddy admin unavailable after startup")
+        if (startup_output.length > 0) {
+          console.log("recent caddy startup output:")
+          for (let line of startup_output) {
+            console.log(line)
+          }
+        }
+        return
+      }
+      this.kernel.caddy_startup_output = startup_output.slice()
       console.log("kernel.refresh bin.caddy.start")
       this.kernel.peer.announce()
       console.log("announced to peers")

package/package.json

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

package/server/index.js

@@ -80,7 +80,6 @@ const { createTaskPackageService } = require("./lib/task_packages")
 const { createTaskWorkspaceLinkService } = require("./lib/task_workspace_links")
 const { createContentValidationService } = require("./lib/content_validation")
 const { buildSecureRouterDebugSnapshot, createSecureRouterDebugStore } = require("./lib/secure_router_debug")
-const { ensureSecureRouterReady } = require("./lib/secure_router_ready")
 const AppRegistryService = require("./lib/app_registry")
 const AppLogService = require("./lib/app_logs")
 const AppSearchService = require("./lib/app_search")
@@ -5520,9 +5519,6 @@ class Server {
 
     return { success: true }
   }
-  async ensureSecureRouterReady(timeout = 120000, interval = 500) {
-    return ensureSecureRouterReady(this, timeout, interval)
-  }
   async start(options) {
     this.debug = false
     if (options) {
@@ -5792,12 +5788,6 @@ 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,

package/server/lib/secure_router_debug.js

@@ -72,6 +72,9 @@ async function buildSecureRouterDebugSnapshot(server, store) {
   const startupStatus = server && typeof server.getStartupStatus === "function"
     ? server.getStartupStatus()
     : null
+  const caddyStartupOutput = kernel && Array.isArray(kernel.caddy_startup_output)
+    ? clone(kernel.caddy_startup_output)
+    : []
   const state = store && store.state ? clone(store.state) : {}
   const events = store && Array.isArray(store.events) ? clone(store.events) : []
   return {
@@ -87,6 +90,7 @@ async function buildSecureRouterDebugSnapshot(server, store) {
       start_attempted: !!state.caddy_start_attempted,
       start_finished: !!state.caddy_start_finished,
       start_error: state.caddy_start_error || null,
+      startup_output: caddyStartupOutput,
     },
     peer: {
       host: peer && peer.host ? peer.host : null,

package/server/public/setup-wait-debug.js

@@ -76,6 +76,10 @@
       if (serverDebug) {
         lines.push(`Flags: ${JSON.stringify(serverDebug.flags || null)}`)
         lines.push(`Caddy: ${JSON.stringify(serverDebug.caddy || null)}`)
+        if (serverDebug.caddy && Array.isArray(serverDebug.caddy.startup_output) && serverDebug.caddy.startup_output.length > 0) {
+          lines.push("Caddy startup output:")
+          lines.push(...serverDebug.caddy.startup_output)
+        }
         lines.push(`Peer: ${JSON.stringify(serverDebug.peer || null)}`)
         lines.push(`Router: ${JSON.stringify(serverDebug.router || null)}`)
         lines.push(`Wait: ${JSON.stringify(serverDebug.wait || null)}`)

package/server/lib/secure_router_ready.js

@@ -1,96 +0,0 @@
-const { createSecureRouterDebugStore, recordSecureRouterDebug } = require("./secure_router_debug")
-
-async function ensureSecureRouterReady(server, timeout = 120000, interval = 500) {
-  if (!(server.kernel && server.kernel.peer && server.kernel.peer.https_active)) {
-    return { success: true, stage: "disabled" }
-  }
-  server.secure_router_debug = createSecureRouterDebugStore()
-  recordSecureRouterDebug(server.secure_router_debug, "wait started", {
-    active: true,
-    started_at: new Date().toISOString(),
-    last_status: null,
-    caddy_start_attempted: false,
-    caddy_start_finished: false,
-    caddy_start_error: null,
-    refresh_attempted: false,
-    refresh_finished: false,
-    refresh_error: null,
-  })
-  const caddy = server.kernel && server.kernel.bin && server.kernel.bin.mod
-    ? server.kernel.bin.mod.caddy
-    : null
-  const deadline = Date.now() + timeout
-  let startedCaddyManually = false
-  let refreshedRouter = false
-  let lastStatus = null
-  let lastStatusSummary = null
-  while (Date.now() < deadline) {
-    lastStatus = await server.check_router_up()
-    const statusSummary = lastStatus && lastStatus.success
-      ? "success"
-      : (lastStatus && lastStatus.error ? lastStatus.error : JSON.stringify(lastStatus))
-    if (statusSummary !== lastStatusSummary) {
-      lastStatusSummary = statusSummary
-      recordSecureRouterDebug(server.secure_router_debug, `check_router_up -> ${statusSummary}`, {
-        last_status: lastStatus
-      })
-    }
-    if (lastStatus && lastStatus.success) {
-      recordSecureRouterDebug(server.secure_router_debug, "wait success", {
-        active: false
-      })
-      return lastStatus
-    }
-    if (
-      lastStatus &&
-      lastStatus.error === "caddy admin unavailable" &&
-      !startedCaddyManually &&
-      caddy &&
-      typeof caddy.start === "function"
-    ) {
-      startedCaddyManually = true
-      recordSecureRouterDebug(server.secure_router_debug, "manual caddy.start() attempted", {
-        caddy_start_attempted: true
-      })
-      try {
-        await caddy.start()
-        recordSecureRouterDebug(server.secure_router_debug, "manual caddy.start() finished", {
-          caddy_start_finished: true
-        })
-      } catch (e) {
-        recordSecureRouterDebug(server.secure_router_debug, "manual caddy.start() failed", {
-          caddy_start_error: e && e.message ? e.message : String(e)
-        })
-        throw e
-      }
-      continue
-    }
-    if (!refreshedRouter) {
-      refreshedRouter = true
-      recordSecureRouterDebug(server.secure_router_debug, "kernel.refresh(true) attempted", {
-        refresh_attempted: true
-      })
-      await server.kernel.refresh(true).then(() => {
-        recordSecureRouterDebug(server.secure_router_debug, "kernel.refresh(true) finished", {
-          refresh_finished: true
-        })
-      }).catch((e) => {
-        recordSecureRouterDebug(server.secure_router_debug, "kernel.refresh(true) failed", {
-          refresh_error: e && e.message ? e.message : String(e)
-        })
-      })
-      continue
-    }
-    await new Promise((resolve) => {
-      setTimeout(resolve, interval)
-    })
-  }
-  recordSecureRouterDebug(server.secure_router_debug, "wait timeout", {
-    active: false
-  })
-  throw new Error(lastStatus && lastStatus.error ? lastStatus.error : "secure router did not come up")
-}
-
-module.exports = {
-  ensureSecureRouterReady,
-}