pinokiod 7.5.24 → 7.5.26

package/server/index.js

@@ -84,6 +84,7 @@ 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 logRedaction = require("./lib/log_redaction")
 const AppRegistryService = require("./lib/app_registry")
 const AppLogService = require("./lib/app_logs")
 const AppLogReportService = require("./lib/app_log_report")
@@ -858,6 +859,50 @@ class Server {
     }
     return cfg
   }
+  defaultAppLogLaunchPath(menu) {
+    const stack = Array.isArray(menu) ? [...menu] : []
+    while (stack.length > 0) {
+      const item = stack.shift()
+      if (!item || typeof item !== "object") {
+        continue
+      }
+      if (Array.isArray(item.menu)) {
+        stack.unshift(...item.menu)
+      }
+      if (!item.default || typeof item.href !== "string") {
+        continue
+      }
+      let pathname
+      try {
+        pathname = new URL(item.href, "http://localhost").pathname
+      } catch (_) {
+        continue
+      }
+      if (pathname.startsWith("/api/")) {
+        try {
+          const parts = pathname.slice("/api/".length).split("/").filter(Boolean).map(decodeURIComponent)
+          return this.kernel.path("api", ...parts)
+        } catch (_) {
+          return ""
+        }
+      }
+      if (PluginSources.isRunPath(pathname)) {
+        return PluginSources.resolveRunPath(this.kernel, pathname)
+      }
+    }
+    return ""
+  }
+  async reserveDefaultAppLogSession(menu, enabled, options = {}) {
+    if (!enabled || !this.kernel || !this.kernel.api || !this.kernel.api.logSessions) {
+      return
+    }
+    const launchPath = this.defaultAppLogLaunchPath(menu)
+    if (launchPath) {
+      await this.kernel.api.logSessions.reserveLaunch(launchPath, {
+        existingRoutineOnly: !!options.existingRoutineOnly
+      })
+    }
+  }
   async renderIndex(name, cfg) {
     let p = this.kernel.path("api", name)
     let index_path = path.resolve(p, "index.html")
@@ -1337,7 +1382,6 @@ class Server {
     } catch(e) {
       config.menu = []
     }
-
     await this.renderMenu(req, uri, name, config, [])
 
     let platform = os.platform()
@@ -1425,6 +1469,10 @@ class Server {
       run_tab = "/p/" + name
       autoselect = false
     }
+    await this.reserveDefaultAppLogSession(
+      config && config.menu,
+      autoselect && env.PINOKIO_SCRIPT_DEFAULT && env.PINOKIO_SCRIPT_DEFAULT.toString().toLowerCase() === "true"
+    )
     let dev_tab = "/p/" + name + "/dev"
     let review_tab = "/p/" + name + "/review"
     let files_tab = "/p/" + name + "/files"
@@ -6328,8 +6376,7 @@ class Server {
         path.resolve(__dirname, "views")
       ])
     }
-    this.app.use(express.json());
-    this.app.use(express.urlencoded({ extended: true }));
+    logRedaction.createLogRedactionBodyParsers(express).forEach((parser) => this.app.use(parser))
     this.app.use(cookieParser());
     this.app.use(session({
       secret: "secret",
@@ -8247,6 +8294,9 @@ class Server {
         })
         return
       }
+      if (!workspace) {
+        await logRedaction.writeCurrentLogSnapshot(this.kernel, this.version)
+      }
       res.render("logs", {
         current_host: this.kernel.peer.host,
         ...peerAccess,
@@ -8335,6 +8385,7 @@ class Server {
         entries
       })
     }))
+    this.app.get("/pinokio/logs/file", ex(logRedaction.createTopLevelLogFileHandler(this)))
     this.app.get("/api/logs/stream", ex(async (req, res) => {
       const workspace = typeof req.query.workspace === 'string' ? req.query.workspace.trim() : ''
       let context
@@ -13519,6 +13570,104 @@ class Server {
         requirements_pending,
       })
     }))
+    this.app.get("/net/:name/routes", ex(async (req, res) => {
+      const protocol = req.get('X-Forwarded-Proto') || "http"
+      await this.kernel.peer.check_peers()
+
+      const list = this.kernel.peer.info ? this.getPeers() : []
+      let processes = []
+      let host
+      let peer
+      for (let item of list) {
+        if (item.name === req.params.name) {
+          processes = item.processes
+          host = item.host
+          peer = item
+        }
+      }
+
+      let peer_info = host && this.kernel.peer.info ? this.kernel.peer.info[host] : null
+      if (!peer_info && req.params.name === this.kernel.peer.name) {
+        try {
+          await this.kernel.peer.refresh_host(this.kernel.peer.host)
+        } catch (e) {
+        }
+        host = this.kernel.peer.host
+        peer_info = this.kernel.peer.info && this.kernel.peer.info[host] ? this.kernel.peer.info[host] : null
+        if (peer_info) {
+          peer = peer_info
+        }
+      }
+
+      if (peer_info) {
+        processes = peer_info.router_info || []
+      }
+      for (let i = 0; i < processes.length; i++) {
+        if (!processes[i].icon) {
+          if (protocol === "https") {
+            processes[i].icon = processes[i].https_icon
+          } else {
+            processes[i].icon = processes[i].http_icon
+          }
+        }
+      }
+
+      const installed = peer_info ? peer_info.installed : []
+      const serverless_mapping = peer_info ? peer_info.rewrite_mapping : {}
+      const serverless = Object.keys(serverless_mapping).map((name) => {
+        return serverless_mapping[name]
+      })
+      const static_routes = this.kernel.router && this.kernel.router.rewrite_mapping
+        ? Object.keys(this.kernel.router.rewrite_mapping).map((key) => this.kernel.router.rewrite_mapping[key])
+        : []
+      const current_host = this.kernel.peer.host
+      const showStaticRoutes = false
+      const visibleStaticRoutes = showStaticRoutes ? static_routes : []
+      const routeCount = current_host === host
+        ? processes.length + visibleStaticRoutes.length
+        : processes.length + installed.length + serverless.length
+      const allow_dns_creation = !!peer_info && req.params.name === this.kernel.peer.name
+      const locals = {
+        static_routes,
+        visibleStaticRoutes,
+        showStaticRoutes,
+        processes,
+        installed,
+        serverless,
+        host,
+        peer,
+        protocol,
+        current_host,
+        allow_dns_creation,
+        routeCount,
+      }
+      const fingerprintPayload = current_host === host
+        ? { current_host, host, processes, visibleStaticRoutes }
+        : { current_host, host, processes, installed, serverless }
+      const fingerprint = crypto
+        .createHash('sha256')
+        .update(JSON.stringify(fingerprintPayload))
+        .digest('hex')
+      const renderPartial = (name) => {
+        return new Promise((resolve, reject) => {
+          this.app.render(name, locals, (err, html) => {
+            if (err) {
+              reject(err)
+            } else {
+              resolve(html)
+            }
+          })
+        })
+      }
+      const routes_html = await renderPartial("partials/net_route_list")
+      const summary_html = await renderPartial("partials/net_summary")
+      res.json({
+        success: true,
+        fingerprint,
+        routes_html,
+        summary_html,
+      })
+    }))
     this.app.get("/net/:name/diff", ex(async (req, res) => {
       try {
         let processes = this.kernel.peer.info[this.kernel.peer.host].router_info
@@ -15142,6 +15291,12 @@ class Server {
         }
       }
       await this.renderMenu(req, uri, name, config, [])
+      const env = await this.kernel.env("api/" + name)
+      await this.reserveDefaultAppLogSession(
+        config && config.menu,
+        env.PINOKIO_SCRIPT_DEFAULT && env.PINOKIO_SCRIPT_DEFAULT.toString().toLowerCase() === "true",
+        { existingRoutineOnly: true }
+      )
 
       ejs.renderFile(path.resolve(__dirname, "views/partials/menu.ejs"), { menu: config.menu }, (err, html) => {
         res.send(html)
@@ -15806,37 +15961,19 @@ class Server {
         }
         return
       }
-
-      let states = this.kernel.shell.shells.map((s) => {
-        return {
-          state: s.state,
-          id: s.id,
-          group: s.group,
-          env: s.env,
-          path: s.path,
-          cmd: s.cmd,
-          done: s.done,
-          ready: s.ready,
-        }
-      })
-
-      let info = {
-        platform: this.kernel.platform,
-        arch: this.kernel.arch,
-        running: this.kernel.api.running,
-        home: this.kernel.homedir,
-        vars: this.kernel.vars,
-        memory: this.kernel.memory,
-        procs: this.kernel.procs,
-        gpu: this.kernel.gpu,
-        gpus: this.kernel.gpus,
-        version: this.version,
-        ...this.kernel.sysinfo
+      const redactionOverridesRequested = Boolean(req.body && Object.prototype.hasOwnProperty.call(req.body, 'redacted_overrides'))
+      let redactionOverrides = []
+      try {
+        redactionOverrides = logRedaction.normalizeLogRedactionOverrides(req.body || {})
+      } catch (error) {
+        res.status(400).json({ error: error && error.message ? error.message : 'Invalid redaction overrides' })
+        return
       }
-      await fs.promises.writeFile(this.kernel.path("logs/system.json"), JSON.stringify(info, null, 2))
-      await fs.promises.writeFile(this.kernel.path("logs/state.json"), JSON.stringify(states, null, 2))
+
+      await logRedaction.writeCurrentLogSnapshot(this.kernel, this.version)
 
 
+      await fs.promises.rm(this.kernel.path("exported_logs"), { recursive: true, force: true }).catch(() => {})
       await fs.promises.cp(
         this.kernel.path("logs"),
         this.kernel.path("exported_logs")
@@ -15847,8 +15984,22 @@ class Server {
 
       let folder = this.kernel.path("exported_logs")
       let zipPath = this.kernel.path("logs.zip")
+      if (redactionOverridesRequested) {
+        await fs.promises.rm(zipPath, { force: true }).catch(() => {})
+      }
+      let appliedRedactionOverrides = 0
+      try {
+        if (redactionOverridesRequested) {
+          await logRedaction.assertCompleteLogRedactionOverrides(folder, redactionOverrides)
+        }
+        appliedRedactionOverrides = await logRedaction.applyLogRedactionOverrides(folder, redactionOverrides)
+      } catch (error) {
+        res.status(400).json({ error: error && error.message ? error.message : 'Failed to apply redaction overrides' })
+        return
+      }
+      await fs.promises.rm(zipPath, { force: true }).catch(() => {})
       await compressing.zip.compressDir(folder, zipPath)
-      res.json({ success: true, download: '/pinokio/logs.zip' })
+      res.json({ success: true, download: '/pinokio/logs.zip', redacted_overrides: appliedRedactionOverrides })
     }))
     this.app.get("/pinokio/version", ex(async (req, res) => {
       let version = this.version

package/server/lib/app_log_report.js

@@ -1,6 +1,7 @@
 const fs = require('fs')
 const os = require('os')
 const path = require('path')
+const Environment = require('../../kernel/environment')
 
 const DEFAULT_TAIL_LINES = 800
 const MAX_SECTION_CHARS = 120000
@@ -17,19 +18,26 @@ class AppLogReportService {
     this.kernel = kernel
   }
 
-  async buildReport({ appId, status, tail = DEFAULT_TAIL_LINES, redact = true }) {
-    const appRoot = status && status.path ? status.path : null
-    if (!appRoot) {
+  async buildReport({ appId, status, tail = DEFAULT_TAIL_LINES, redact = true, session = '' }) {
+    const workspaceRoot = status && status.path ? status.path : null
+    if (!workspaceRoot) {
       return null
     }
+    const appRoot = await this.resolveAppRoot(workspaceRoot)
     const tailLines = this.registry.parseTailCount(tail, DEFAULT_TAIL_LINES)
-    const rawSections = await this.collectSections(appRoot, tailLines)
+    const sessionIndex = await this.readSessionIndex(appRoot)
+    const requestedSession = typeof session === 'string' && session.trim()
+      ? session.trim()
+      : sessionIndex.latest_session
+    const manifest = requestedSession ? await this.readSessionManifest(appRoot, requestedSession) : null
+    const selectedSession = manifest ? manifest.id : null
+    const rawSections = await this.collectSections(appRoot, tailLines, manifest)
     const sections = []
     const totals = {}
 
     for (const section of rawSections) {
       if (redact) {
-        const redacted = this.redactText(section.text, { appRoot })
+        const redacted = this.redactText(section.text, { appRoot, workspaceRoot })
         this.mergeCounts(totals, redacted.counts)
         sections.push({
           ...section,
@@ -47,7 +55,7 @@ class AppLogReportService {
     const metadata = {
       app_id: appId,
       title: status.title || appId,
-      repo_url: this.sanitizeRemoteUrl(status.repo_url || this.readGitRemote(appRoot)),
+      repo_url: this.sanitizeRemoteUrl(status.repo_url || this.readGitRemote(workspaceRoot)),
       generated_at: new Date().toISOString(),
       pinokiod: this.readPinokioVersion(),
       platform: os.platform(),
@@ -55,7 +63,11 @@ class AppLogReportService {
       node: process.version,
       tail_count: tailLines,
       system_spec: this.buildSystemSpec(),
-      redaction_mode: redact ? 'server_deterministic' : 'none'
+      redaction_mode: redact ? 'server_deterministic' : 'none',
+      latest_session: sessionIndex.latest_session,
+      session: selectedSession,
+      sessions: sessionIndex.sessions,
+      no_session: !manifest
     }
 
     return {
@@ -67,54 +79,121 @@ class AppLogReportService {
     }
   }
 
-  async collectSections(appRoot, tailLines) {
+  async collectSections(appRoot, tailLines, manifest = null) {
     const sections = []
-    const apiLogsRoot = path.resolve(appRoot, 'logs', 'api')
-
-    if (await this.registry.pathIsDirectory(apiLogsRoot)) {
-      const latestFiles = await this.findNamedFiles(apiLogsRoot, 'latest')
-      for (const file of latestFiles) {
-        const relativeDir = path.relative(apiLogsRoot, path.dirname(file))
-        const script = this.toPosix(relativeDir)
+    if (!manifest || !Array.isArray(manifest.runs)) {
+      return sections
+    }
+    const logsRoot = path.resolve(appRoot, 'logs')
+    for (const run of manifest.runs) {
+      const logs = Array.isArray(run && run.logs) ? run.logs : []
+      for (const log of logs) {
+        const file = this.resolveManifestLog(appRoot, log)
+        if (!file) {
+          continue
+        }
+        const relativeLog = this.toPosix(path.relative(appRoot, file))
         sections.push(await this.buildSection({
           appRoot,
-          root: apiLogsRoot,
+          root: logsRoot,
           file,
-          source: 'api',
-          script,
+          source: this.sourceFromRelativeFile(relativeLog),
+          script: run.script || this.scriptFromRelativeFile(relativeLog),
           tailLines
         }))
       }
     }
 
-    return sections
-      .filter(Boolean)
-      .sort((a, b) => this.compareSections(a, b))
+    return sections.filter(Boolean)
+  }
+
+  async resolveAppRoot(workspaceRoot) {
+    const fallback = path.resolve(workspaceRoot)
+    if (!this.kernel || typeof this.kernel.exists !== 'function') {
+      return fallback
+    }
+    try {
+      const root = await Environment.get_root({ path: fallback }, this.kernel)
+      return root && root.root ? path.resolve(root.root) : fallback
+    } catch (_) {
+      return fallback
+    }
+  }
+
+  safeSessionId(value) {
+    return typeof value === 'string' && /^[A-Za-z0-9._-]+$/.test(value) ? value : ''
   }
 
-  async findNamedFiles(root, filename) {
-    const out = []
-    const walk = async (dir) => {
-      let entries = []
-      try {
-        entries = await fs.promises.readdir(dir, { withFileTypes: true })
-      } catch (_) {
-        return
+  async readSessionIndex(appRoot) {
+    try {
+      const indexPath = path.resolve(appRoot, 'logs', 'sessions', 'index.json')
+      const parsed = JSON.parse(await fs.promises.readFile(indexPath, 'utf8'))
+      if (!parsed || typeof parsed !== 'object' || !Array.isArray(parsed.sessions)) {
+        return { latest_session: null, sessions: [] }
       }
-      for (const entry of entries) {
-        const entryPath = path.resolve(dir, entry.name)
-        if (!this.registry.isPathWithin(root, entryPath)) {
-          continue
-        }
-        if (entry.isDirectory()) {
-          await walk(entryPath)
-        } else if (entry.name === filename) {
-          out.push(entryPath)
-        }
+      return {
+        latest_session: this.safeSessionId(parsed.latest_session) || null,
+        sessions: parsed.sessions
+          .filter((entry) => entry && typeof entry === 'object' && this.safeSessionId(entry.id))
+          .map((entry) => ({
+            id: entry.id,
+            created_at: typeof entry.created_at === 'string' ? entry.created_at : null,
+            updated_at: typeof entry.updated_at === 'string' ? entry.updated_at : null,
+            runs: Array.isArray(entry.runs) ? entry.runs.filter((run) => typeof run === 'string') : []
+          }))
       }
+    } catch (_) {
+      return { latest_session: null, sessions: [] }
     }
-    await walk(root)
-    return out
+  }
+
+  async readSessionManifest(appRoot, sessionId) {
+    const safeId = this.safeSessionId(sessionId)
+    if (!safeId) {
+      return null
+    }
+    try {
+      const manifestPath = path.resolve(appRoot, 'logs', 'sessions', `${safeId}.json`)
+      const parsed = JSON.parse(await fs.promises.readFile(manifestPath, 'utf8'))
+      if (!parsed || typeof parsed !== 'object' || parsed.id !== safeId || !Array.isArray(parsed.runs)) {
+        return null
+      }
+      return parsed
+    } catch (_) {
+      return null
+    }
+  }
+
+  resolveManifestLog(appRoot, log) {
+    if (!log || typeof log.path !== 'string' || !log.path.trim()) {
+      return null
+    }
+    const logsRoot = path.resolve(appRoot, 'logs')
+    const sessionsRoot = path.resolve(logsRoot, 'sessions')
+    const file = path.resolve(appRoot, log.path)
+    if (!this.registry.isPathWithin(logsRoot, file)) {
+      return null
+    }
+    if (this.registry.isPathWithin(sessionsRoot, file)) {
+      return null
+    }
+    if (path.basename(file) === 'latest') {
+      return null
+    }
+    return file
+  }
+
+  sourceFromRelativeFile(relativeFile) {
+    const parts = String(relativeFile || '').split('/').filter(Boolean)
+    return parts[0] === 'logs' && parts[1] ? parts[1] : 'api'
+  }
+
+  scriptFromRelativeFile(relativeFile) {
+    const parts = String(relativeFile || '').split('/').filter(Boolean)
+    if (parts[0] === 'logs' && parts[1] === 'api' && parts.length > 3) {
+      return parts.slice(2, -1).join('/')
+    }
+    return ''
   }
 
   async buildSection({ appRoot, root, file, source, script, tailLines }) {
@@ -211,9 +290,11 @@ class AppLogReportService {
       /(^|[\s"'(=])\/home\/[^/\s"')]+/g,
       /(^|[\s"'(=])[A-Za-z]:\\Users\\[^\\\s"')]+/g
     ]
-    const appRoot = context.appRoot ? String(context.appRoot) : ''
-    if (appRoot) {
-      patterns.push(new RegExp(`(^|[\\s"'(=])${escapeRegExp(appRoot)}`, 'g'))
+    const roots = [context.workspaceRoot, context.appRoot]
+      .map((root) => root ? String(root) : '')
+      .filter((root, index, values) => root && values.indexOf(root) === index)
+    for (const root of roots) {
+      patterns.push(new RegExp(`(^|[\\s"'(=])${escapeRegExp(root)}`, 'g'))
     }
     return patterns
   }
@@ -257,7 +338,7 @@ class AppLogReportService {
     lines.push('', '## Logs')
 
     if (sections.length === 0) {
-      lines.push('', 'No app log files were found.')
+      lines.push('', metadata.no_session ? 'No session log bundle found.' : 'No app log files were found.')
     }
 
     for (const section of sections) {
@@ -330,22 +411,6 @@ class AppLogReportService {
     return text
   }
 
-  compareSections(a, b) {
-    const sourceOrder = { api: 0, shell: 1 }
-    const bySource = (sourceOrder[a.source] ?? 99) - (sourceOrder[b.source] ?? 99)
-    if (bySource !== 0) return bySource
-    return this.scriptRank(a.script) - this.scriptRank(b.script)
-      || String(a.script || '').localeCompare(String(b.script || ''))
-      || String(a.file || '').localeCompare(String(b.file || ''))
-  }
-
-  scriptRank(script) {
-    const value = String(script || '').toLowerCase()
-    const ordered = ['install', 'update', 'start', 'run', 'launch', 'serve', 'shell']
-    const idx = ordered.findIndex((name) => value === name || value.startsWith(`${name}.`) || value.includes(`/${name}.`))
-    return idx >= 0 ? idx : ordered.length
-  }
-
   toPosix(value) {
     return String(value || '').split(path.sep).filter(Boolean).join('/')
   }