pinokiod 3.270.0 → 3.272.0

package/server/index.js

@@ -40,6 +40,8 @@ const ejs = require('ejs');
 
 const DEFAULT_PORT = 42000
 const NOTIFICATION_SOUND_EXTENSIONS = new Set(['.aac', '.flac', '.m4a', '.mp3', '.ogg', '.wav', '.webm'])
+const LOG_STREAM_INITIAL_BYTES = 512 * 1024
+const LOG_STREAM_KEEPALIVE_MS = 25000
 
 const ex = fn => (req, res, next) => {
   Promise.resolve(fn(req, res, next)).catch(next);
@@ -3124,6 +3126,116 @@ class Server {
     return { peer_access_points, peer_url, peer_qr }
   }
 
+  async ensureLogsRootDirectory() {
+    const logsRoot = path.resolve(this.kernel.path("logs"))
+    await fs.promises.mkdir(logsRoot, { recursive: true })
+    return logsRoot
+  }
+  async resolveLogsRoot(options = {}) {
+    const workspace = typeof options.workspace === 'string' ? options.workspace.trim() : ''
+    if (workspace) {
+      const apiRoot = path.resolve(this.kernel.path("api"))
+      const segments = workspace.replace(/\\+/g, '/').split('/').map((segment) => segment.trim()).filter((segment) => segment.length > 0 && segment !== '.')
+      if (segments.length === 0) {
+        throw new Error('Workspace not found')
+      }
+      const normalized = segments.join('/')
+      const workspacePath = path.resolve(apiRoot, normalized)
+      const relative = path.relative(apiRoot, workspacePath)
+      if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) {
+        throw new Error('Invalid workspace path')
+      }
+      let workspaceStats
+      try {
+        workspaceStats = await fs.promises.stat(workspacePath)
+      } catch (error) {
+        if (error.code === 'ENOENT') {
+          throw new Error('Workspace not found')
+        }
+        throw error
+      }
+      if (!workspaceStats.isDirectory()) {
+        throw new Error('Workspace path is not a directory')
+      }
+      const candidate = path.resolve(workspacePath, 'logs')
+      await fs.promises.mkdir(candidate, { recursive: true })
+      return {
+        logsRoot: candidate,
+        displayPath: this.formatLogsDisplayPath(candidate),
+        title: normalized
+      }
+    }
+    const logsRoot = await this.ensureLogsRootDirectory()
+    return {
+      logsRoot,
+      displayPath: this.formatLogsDisplayPath(logsRoot),
+      title: null
+    }
+  }
+  sanitizeWorkspaceForFilename(workspace) {
+    if (!workspace || typeof workspace !== 'string') {
+      return 'workspace'
+    }
+    const sanitized = workspace.replace(/[^a-zA-Z0-9._-]/g, '_')
+    return sanitized.length > 0 ? sanitized : 'workspace'
+  }
+  async removeRouterSnapshots(targetDir) {
+    try {
+      const entries = await fs.promises.readdir(targetDir, { withFileTypes: true })
+      for (const entry of entries) {
+        if (entry.isFile() && /^router-default-\d+\.json$/.test(entry.name)) {
+          await fs.promises.rm(path.join(targetDir, entry.name)).catch(() => {})
+        }
+      }
+    } catch (_) {}
+  }
+  formatLogsDisplayPath(absolutePath) {
+    if (!absolutePath) {
+      return ''
+    }
+    const systemHome = os.homedir ? path.resolve(os.homedir()) : null
+    if (systemHome) {
+      const relativeToSystem = path.relative(systemHome, absolutePath)
+      if (!relativeToSystem || (!relativeToSystem.startsWith('..') && !path.isAbsolute(relativeToSystem))) {
+        if (!relativeToSystem) {
+          return '~'
+        }
+        const normalized = relativeToSystem.split(path.sep).join('/')
+        return `~/${normalized}`
+      }
+    }
+    const configuredHome = this.kernel.homedir ? path.resolve(this.kernel.homedir) : null
+    if (configuredHome) {
+      const relativeToConfigured = path.relative(configuredHome, absolutePath)
+      if (!relativeToConfigured || (!relativeToConfigured.startsWith('..') && !path.isAbsolute(relativeToConfigured))) {
+        if (!relativeToConfigured) {
+          return '~'
+        }
+        const normalized = relativeToConfigured.split(path.sep).join('/')
+        return `~/${normalized}`
+      }
+    }
+    return absolutePath
+  }
+  formatLogsRelativePath(relativePath = '') {
+    if (!relativePath || relativePath === '.') {
+      return ''
+    }
+    return relativePath.split(path.sep).join('/')
+  }
+  resolveLogsAbsolutePath(logsRoot, requestedPath = '') {
+    const trimmed = typeof requestedPath === 'string' ? requestedPath.trim() : ''
+    const normalizedRequest = trimmed ? path.normalize(trimmed) : '.'
+    const absolutePath = path.resolve(logsRoot, normalizedRequest)
+    const relativePath = path.relative(logsRoot, absolutePath)
+    if (relativePath && (relativePath.startsWith('..') || path.isAbsolute(relativePath))) {
+      throw new Error('INVALID_LOGS_PATH')
+    }
+    return {
+      absolutePath,
+      relativePath: relativePath === '.' ? '' : relativePath
+    }
+  }
 
   async syncConfig() {
 
@@ -4311,6 +4423,263 @@ class Server {
         list,
       })
     }))
+    this.app.get("/logs", ex(async (req, res) => {
+      const peerAccess = await this.composePeerAccessPayload()
+      const list = this.getPeers()
+      const workspace = typeof req.query.workspace === 'string' ? req.query.workspace.trim() : ''
+      let context
+      const downloadUrl = workspace ? `/pinokio/logs.zip?workspace=${encodeURIComponent(workspace)}` : '/pinokio/logs.zip'
+      try {
+        context = await this.resolveLogsRoot({ workspace })
+      } catch (error) {
+        res.status(404).render("logs", {
+          current_host: this.kernel.peer.host,
+          ...peerAccess,
+          portal: this.portal,
+          logo: this.logo,
+          theme: this.theme,
+          agent: req.agent,
+          list,
+          logsRootDisplay: '',
+          logsWorkspace: workspace || null,
+          logsTitle: workspace || null,
+          logsError: error && error.message ? error.message : 'Workspace not found',
+          logsDownloadUrl: downloadUrl,
+        })
+        return
+      }
+      res.render("logs", {
+        current_host: this.kernel.peer.host,
+        ...peerAccess,
+        portal: this.portal,
+        logo: this.logo,
+        theme: this.theme,
+        agent: req.agent,
+        list,
+        logsRootDisplay: context.displayPath,
+        logsWorkspace: workspace || null,
+        logsTitle: context.title,
+        logsError: null,
+        logsDownloadUrl: downloadUrl,
+      })
+    }))
+    this.app.get("/api/logs/tree", ex(async (req, res) => {
+      const workspace = typeof req.query.workspace === 'string' ? req.query.workspace.trim() : ''
+      let context
+      try {
+        context = await this.resolveLogsRoot({ workspace })
+      } catch (error) {
+        res.status(404).json({ error: error && error.message ? error.message : 'Workspace not found' })
+        return
+      }
+      const logsRoot = context.logsRoot
+      let descriptor
+      try {
+        descriptor = this.resolveLogsAbsolutePath(logsRoot, req.query.path || '')
+      } catch (_) {
+        res.status(400).json({ error: "Invalid path" })
+        return
+      }
+      let stats
+      try {
+        stats = await fs.promises.stat(descriptor.absolutePath)
+      } catch (error) {
+        res.status(404).json({ error: "Path not found" })
+        return
+      }
+      if (!stats.isDirectory()) {
+        res.status(400).json({ error: "Path is not a directory" })
+        return
+      }
+      let dirents
+      try {
+        dirents = await fs.promises.readdir(descriptor.absolutePath, { withFileTypes: true })
+      } catch (error) {
+        res.status(500).json({ error: "Failed to read directory", detail: error.message })
+        return
+      }
+      const entries = []
+      for (const dirent of dirents) {
+        if (dirent.name === '.' || dirent.name === '..') {
+          continue
+        }
+        const entryPath = path.join(descriptor.absolutePath, dirent.name)
+        let entryStats
+        try {
+          entryStats = await fs.promises.stat(entryPath)
+        } catch (error) {
+          continue
+        }
+        const relativePath = path.relative(logsRoot, entryPath)
+        entries.push({
+          name: dirent.name,
+          path: this.formatLogsRelativePath(relativePath),
+          type: entryStats.isDirectory() ? "directory" : "file",
+          size: entryStats.isDirectory() ? null : entryStats.size,
+          modified: entryStats.mtime
+        })
+      }
+      entries.sort((a, b) => {
+        if (a.type === b.type) {
+          return a.name.localeCompare(b.name)
+        }
+        return a.type === "directory" ? -1 : 1
+      })
+      res.set("Cache-Control", "no-store")
+      res.json({
+        path: this.formatLogsRelativePath(descriptor.relativePath),
+        entries
+      })
+    }))
+    this.app.get("/api/logs/stream", ex(async (req, res) => {
+      const workspace = typeof req.query.workspace === 'string' ? req.query.workspace.trim() : ''
+      let context
+      try {
+        context = await this.resolveLogsRoot({ workspace })
+      } catch (error) {
+        res.status(404).json({ error: error && error.message ? error.message : 'Workspace not found' })
+        return
+      }
+      const logsRoot = context.logsRoot
+      let descriptor
+      try {
+        descriptor = this.resolveLogsAbsolutePath(logsRoot, req.query.path || '')
+      } catch (_) {
+        res.status(400).json({ error: "Invalid path" })
+        return
+      }
+      let stats
+      try {
+        stats = await fs.promises.stat(descriptor.absolutePath)
+      } catch (error) {
+        res.status(404).json({ error: "File not found" })
+        return
+      }
+      if (!stats.isFile()) {
+        res.status(400).json({ error: "Path is not a file" })
+        return
+      }
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache, no-transform",
+        Connection: "keep-alive"
+      })
+      if (res.flushHeaders) {
+        res.flushHeaders()
+      }
+      if (req.socket && req.socket.setKeepAlive) {
+        req.socket.setKeepAlive(true)
+      }
+      if (req.socket && req.socket.setNoDelay) {
+        req.socket.setNoDelay(true)
+      }
+
+      const sendEvent = (eventName, payload) => {
+        if (res.writableEnded) {
+          return
+        }
+        res.write(`event: ${eventName}
+`)
+        res.write(`data: ${JSON.stringify(payload)}
+
+`)
+      }
+      res.write(`retry: 2000
+
+`)
+
+      let watcher
+      let keepAliveTimer
+      let closed = false
+      const cleanup = () => {
+        if (closed) {
+          return
+        }
+        closed = true
+        if (keepAliveTimer) {
+          clearInterval(keepAliveTimer)
+        }
+        if (watcher) {
+          watcher.close()
+        }
+        if (!res.writableEnded) {
+          res.end()
+        }
+      }
+
+      req.on("close", cleanup)
+      req.on("error", cleanup)
+
+      keepAliveTimer = setInterval(() => {
+        if (!res.writableEnded) {
+          res.write(`: keep-alive ${Date.now()}
+
+`)
+        }
+      }, LOG_STREAM_KEEPALIVE_MS)
+
+      const streamRange = (start, end) => {
+        return new Promise((resolve, reject) => {
+          if (end <= start) {
+            resolve()
+            return
+          }
+          const reader = fs.createReadStream(descriptor.absolutePath, {
+            encoding: "utf8",
+            start,
+            end: end - 1
+          })
+          reader.on("data", (chunk) => {
+            sendEvent("chunk", { data: chunk })
+          })
+          reader.on("error", reject)
+          reader.on("end", resolve)
+        })
+      }
+
+      const initialStart = Math.max(0, stats.size - LOG_STREAM_INITIAL_BYTES)
+      sendEvent("snapshot", {
+        path: this.formatLogsRelativePath(descriptor.relativePath),
+        size: stats.size,
+        truncated: initialStart > 0
+      })
+      try {
+        await streamRange(initialStart, stats.size)
+      } catch (error) {
+        sendEvent("server-error", { message: error.message || "Failed to read log file" })
+        cleanup()
+        return
+      }
+      let cursor = stats.size
+      sendEvent("ready", { cursor })
+
+      try {
+        watcher = fs.watch(descriptor.absolutePath, async (eventType) => {
+          if (eventType === "rename") {
+            sendEvent("rotate", { message: "File rotated or removed" })
+            cleanup()
+            return
+          }
+          try {
+            const nextStats = await fs.promises.stat(descriptor.absolutePath)
+            if (nextStats.size < cursor) {
+              cursor = 0
+              sendEvent("reset", { reason: "truncate" })
+            }
+            if (nextStats.size > cursor) {
+              await streamRange(cursor, nextStats.size)
+              cursor = nextStats.size
+            }
+          } catch (error) {
+            sendEvent("server-error", { message: error.message || "Streaming stopped" })
+            cleanup()
+          }
+        })
+      } catch (error) {
+        sendEvent("server-error", { message: error.message || "Unable to watch file" })
+        cleanup()
+      }
+    }))
     this.app.get("/columns", ex(async (req, res) => {
       const originSrc = req.query.origin || req.get('Referrer') || '/';
       const targetSrc = req.query.target || originSrc;
@@ -4347,7 +4716,7 @@ class Server {
       const protocol = (req.$source && req.$source.protocol) || req.protocol || 'http';
       const host = req.get('host') || `localhost:${this.port}`;
       const baseUrl = `${protocol}://${host}`;
-      const targetBase = `${baseUrl}/?create=1&prompt=`;
+      const targetBase = `${baseUrl}/create?prompt=`;
       const safeTargetBase = targetBase.replace(/'/g, "\\'");
       const bookmarkletHref = `javascript:(()=>{window.open('${safeTargetBase}'+encodeURIComponent(window.location.href),'_blank');})();`;
 
@@ -4476,6 +4845,24 @@ class Server {
       })
     }))
     const renderHomePage = ex(async (req, res) => {
+      if (Object.prototype.hasOwnProperty.call(req.query, 'create')) {
+        const protocol = (req.$source && req.$source.protocol) || req.protocol || 'http'
+        const host = req.get('host') || `localhost:${this.port}`
+        const baseUrl = `${protocol}://${host}`
+        const target = new URL('/create', baseUrl)
+        for (const [key, value] of Object.entries(req.query)) {
+          if (key === 'create' || key === 'session') {
+            continue
+          }
+          if (Array.isArray(value)) {
+            value.forEach((val) => target.searchParams.append(key, val))
+          } else if (value != null) {
+            target.searchParams.set(key, value)
+          }
+        }
+        res.redirect(target.pathname + target.search + target.hash)
+        return
+      }
       // check bin folder
 //      let bin_path = this.kernel.path("bin/miniconda")
 //      let bin_exists = await this.exists(bin_path)
@@ -4616,11 +5003,12 @@ class Server {
       const host = req.get('host') || `localhost:${this.port}`
       const baseUrl = `${protocol}://${host}`
 
-      const initialUrl = new URL('/home', baseUrl)
+      const wantsCreatePage = Object.prototype.hasOwnProperty.call(req.query, 'create')
+      const initialUrl = new URL(wantsCreatePage ? '/create/page' : '/home', baseUrl)
       const defaultUrl = new URL('/home', baseUrl)
 
       for (const [key, value] of Object.entries(req.query)) {
-        if (key === 'session') {
+        if (key === 'session' || key === 'create') {
           continue
         }
         if (Array.isArray(value)) {
@@ -4649,6 +5037,76 @@ class Server {
       })
     }))
 
+    this.app.get("/create", ex(async (req, res) => {
+      const protocol = (req.$source && req.$source.protocol) || req.protocol || 'http'
+      const host = req.get('host') || `localhost:${this.port}`
+      const baseUrl = `${protocol}://${host}`
+
+      const initialUrl = new URL('/create/page', baseUrl)
+      const defaultUrl = new URL('/home', baseUrl)
+
+      for (const [key, value] of Object.entries(req.query)) {
+        if (key === 'session' || key === 'create') {
+          continue
+        }
+        if (Array.isArray(value)) {
+          value.forEach((val) => initialUrl.searchParams.append(key, val))
+        } else if (value != null) {
+          initialUrl.searchParams.set(key, value)
+        }
+      }
+
+      if (!home) {
+        defaultUrl.searchParams.set('mode', 'settings')
+      }
+
+      res.render('layout', {
+        platform: this.kernel.platform,
+        theme: this.theme,
+        agent: req.agent,
+        initialPath: initialUrl.pathname + initialUrl.search + initialUrl.hash,
+        defaultPath: defaultUrl.pathname + defaultUrl.search + defaultUrl.hash,
+        sessionId: typeof req.query.session === 'string' ? req.query.session : null
+      })
+    }))
+
+    this.app.get("/create/page", ex(async (req, res) => {
+      const defaults = {}
+      const templateDefaults = {}
+
+      if (typeof req.query.prompt === 'string' && req.query.prompt.trim()) {
+        defaults.prompt = req.query.prompt.trim()
+      }
+      if (typeof req.query.folder === 'string' && req.query.folder.trim()) {
+        defaults.folder = req.query.folder.trim()
+      }
+      if (typeof req.query.tool === 'string' && req.query.tool.trim()) {
+        defaults.tool = req.query.tool.trim()
+      }
+
+      for (const [key, value] of Object.entries(req.query)) {
+        if ((key.startsWith('template.') || key.startsWith('template_')) && typeof value === 'string') {
+          const name = key.replace(/^template[._]/, '')
+          if (name) {
+            templateDefaults[name] = value.trim()
+          }
+        }
+      }
+
+      if (Object.keys(templateDefaults).length > 0) {
+        defaults.templateValues = templateDefaults
+      }
+
+      res.render('create', {
+        theme: this.theme,
+        agent: req.agent,
+        logo: this.logo,
+        portal: this.portal,
+        paths: [],
+        defaults,
+      })
+    }))
+
     this.app.get("/home", renderHomePage)
 
 
@@ -7687,12 +8145,38 @@ class Server {
         res.json({ error: err.stack })
       }
     }))
-    this.app.get("/pinokio/logs.zip", ex((req, res) => {
+    this.app.get("/pinokio/logs.zip", ex(async (req, res) => {
+      const workspace = typeof req.query.workspace === 'string' ? req.query.workspace.trim() : ''
+      if (workspace) {
+        const safeName = this.sanitizeWorkspaceForFilename(workspace)
+        const zipPath = this.kernel.path(`logs-${safeName}.zip`)
+        try {
+          await fs.promises.access(zipPath, fs.constants.F_OK)
+        } catch (_) {
+          res.status(404).send('Workspace archive not found. Generate a new archive and try again.')
+          return
+        }
+        res.download(zipPath, `${safeName}-logs.zip`)
+        return
+      }
       let zipPath = this.kernel.path("logs.zip")
       res.download(zipPath)
     }))
     this.app.post("/pinokio/log", ex(async (req, res) => {
-
+      const workspace = typeof req.query.workspace === 'string' ? req.query.workspace.trim() : ''
+      if (workspace) {
+        try {
+          const context = await this.resolveLogsRoot({ workspace })
+          const safeName = this.sanitizeWorkspaceForFilename(workspace)
+          const zipPath = this.kernel.path(`logs-${safeName}.zip`)
+          await fs.promises.rm(zipPath, { force: true }).catch(() => {})
+          await compressing.zip.compressDir(context.logsRoot, zipPath)
+          res.json({ success: true, download: `/pinokio/logs.zip?workspace=${encodeURIComponent(workspace)}` })
+        } catch (error) {
+          res.status(404).json({ error: error && error.message ? error.message : 'Workspace not found' })
+        }
+        return
+      }
 
       let states = this.kernel.shell.shells.map((s) => {
         return {
@@ -7728,13 +8212,14 @@ class Server {
         this.kernel.path("logs"),
         this.kernel.path("exported_logs")
       , { recursive: true })
+      await this.removeRouterSnapshots(this.kernel.path("exported_logs"))
       await this.kernel.shell.logs()
 
 
       let folder = this.kernel.path("exported_logs")
       let zipPath = this.kernel.path("logs.zip")
       await compressing.zip.compressDir(folder, zipPath)
-      res.json({ success: true })
+      res.json({ success: true, download: '/pinokio/logs.zip' })
     }))
     this.app.get("/pinokio/version", ex(async (req, res) => {
       let version = this.version