pinokiod 3.337.0 → 3.339.0

package/kernel/util.js

@@ -311,9 +311,40 @@ const port_running = async (host, port) => {
 const parse_env = async (filename) => {
   try {
     const buf = await fs.promises.readFile(filename)
-    const config = dotenv.parse(buf) // will return an object
+    let config = dotenv.parse(buf) // will return an object
+    console.warn(`[parse_env] initial parse keys=${config ? Object.keys(config).length : 0} for ${filename}`)
+
+    // Fallbacks for UTF-16 encodings (common from “Unicode” saves)
+    if ((!config || Object.keys(config).length === 0) && buf.length > 0) {
+      try {
+        const le = dotenv.parse(buf.toString('utf16le'))
+        if (le && Object.keys(le).length > 0) {
+          console.warn(`[parse_env] UTF-16LE fallback succeeded for ${filename}`)
+          config = le
+        } else {
+          console.warn(`[parse_env] UTF-16LE fallback empty for ${filename}`)
+        }
+      } catch (e) {
+        console.warn(`[parse_env] UTF-16LE fallback failed for ${filename}: ${e.message}`)
+      }
+    }
+    if ((!config || Object.keys(config).length === 0) && buf.length > 0) {
+      try {
+        const be = dotenv.parse(buf.toString('utf16be'))
+        if (be && Object.keys(be).length > 0) {
+          console.warn(`[parse_env] UTF-16BE fallback succeeded for ${filename}`)
+          config = be
+        } else {
+          console.warn(`[parse_env] UTF-16BE fallback empty for ${filename}`)
+        }
+      } catch (e) {
+        console.warn(`[parse_env] UTF-16BE fallback failed for ${filename}: ${e.message}`)
+      }
+    }
+
     return config
   } catch (e) {
+    console.warn(`[parse_env] failed to read/parse ${filename}: ${e.message}`)
     return {}
   }
 }

package/package.json

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

package/server/socket.js

@@ -2,6 +2,7 @@ const querystring = require("querystring");
 const WebSocket = require('ws');
 const path = require('path')
 const os = require('os')
+const fs = require('fs')
 const Util = require("../kernel/util")
 const Environment = require("../kernel/environment")
 const NOTIFICATION_CHANNEL = 'kernel.notifications'
@@ -364,12 +365,23 @@ class Socket {
       }
     }
     if (e.data && e.data.raw) {
+      const isShell = this.isShellLog(id, meta)
+      const isShellRun = meta && meta.method === 'shell.run'
+      if (meta.memory) {
+        this.appendEventLog(id, meta, e.data.raw)
+      } else if (meta.source === 'api' && !isShellRun) {
+        this.appendEventLog(id, meta, e.data.raw)
+      }
       if (e.type === "memory") {
         console.log("[memory event id]", id, "caller", e.caller)
       }
-      const tagged = this.tagLines(meta, e.data.raw)
-      this.rawLog[id] = (this.rawLog[id] || "") + (this.rawLog[id] ? "\n" : "") + tagged
-      this.log_buffer(id, this.buffer[id], meta)
+      if (!isShell) {
+        const tagged = this.tagLines(meta, e.data.raw)
+        this.rawLog[id] = (this.rawLog[id] || "") + (this.rawLog[id] ? "\n" : "") + tagged
+        this.log_buffer(id, this.buffer[id], meta)
+      } else {
+        delete this.rawLog[id]
+      }
     }
     //if (e.data && e.data.raw) this.buffer[id] += e.data.raw
     if (e.data && e.data.buf) this.buffer[id] = e.data.buf
@@ -489,6 +501,64 @@ class Socket {
     }
   }
 
+  isShellLog(id, meta) {
+    const idStr = (typeof id === 'string') ? id : ''
+    if (meta && meta.method === 'shell.run') return true
+    if (idStr.startsWith('shell/')) return true
+    if (!path.isAbsolute(idStr) && !idStr.startsWith('http')) return true
+    return false
+  }
+
+  async resolveLogDir(key) {
+    if (path.isAbsolute(key)) {
+      let p = key.replace(/\?.*$/, '')
+      let relative = path.relative(this.parent.kernel.homedir, p)
+      if (relative.startsWith("plugin")) {
+        let m = /\?.*$/.exec(key)
+        if (m && m.length > 0) {
+          let paramStr = m[0]
+          let cwd = new URL("http://localhost" + paramStr).searchParams.get("cwd")
+          let root = await Environment.get_root({ path: cwd }, this.parent.kernel)
+          cwd = root.root
+          return path.resolve(cwd, "logs/dev", relative)
+        }
+      } else if (relative.startsWith("api")) {
+        let filepath_chunks = relative.split(path.sep).slice(2)
+        let cwd = this.parent.kernel.path(...relative.split(path.sep).slice(0, 2))
+        let root = await Environment.get_root({ path: cwd }, this.parent.kernel)
+        cwd = root.root
+        return path.resolve(cwd, "logs/api", ...filepath_chunks)
+      }
+    } else {
+      if (typeof key === 'string' && key.startsWith("shell/")) {
+        let unix_id = key.slice(6)
+        let unix_path = unix_id.split("_")[0]
+        let native_path = Util.u2p(unix_path)
+        let native_path_exists = await new Promise(r=>fs.access(native_path, fs.constants.F_OK, e => r(!e)))
+        if (native_path_exists) {
+          let cwd = native_path
+          let root = await Environment.get_root({ path: cwd }, this.parent.kernel)
+          cwd = root.root
+          return path.resolve(cwd, "logs/shell")
+        }
+      }
+    }
+    return null
+  }
+
+  async appendEventLog(key, meta, text) {
+    const dir = await this.resolveLogDir(key)
+    if (!dir || !text) return
+    try {
+      await fs.promises.mkdir(dir, { recursive: true })
+      const tag = this.logTag(meta)
+      const ts = new Date().toISOString()
+      const lines = String(text || '').split(/\r?\n/).map((line) => `${ts} ${tag} ${line}`).join("\n")
+      const eventPath = path.resolve(dir, "events")
+      await fs.promises.appendFile(eventPath, lines + "\n")
+    } catch (_) {}
+  }
+
   logTag(meta) {
     if (meta && meta.memory) {
       return `[memory]`
@@ -500,7 +570,11 @@ class Socket {
 
   tagLines(meta, text) {
     const tag = this.logTag(meta)
-    return String(text || '').split(/\r?\n/).map((line) => `${tag} ${line}`).join("\n")
+    const message = String(text || '')
+    if (!message) {
+      return tag
+    }
+    return `${tag}\n${message}`
   }
 
   extractMeta(e) {
@@ -610,9 +684,7 @@ class Socket {
           cwd = root.root
           let session = this.sessions[key]
           let logpath = path.resolve(cwd, "logs/shell")
-          const raw = this.rawLog[key] || ""
-          const tagged = buf ? this.tagLines(resolvedMeta, buf) : ""
-          const content = [raw, tagged].filter(Boolean).join("\n")
+          const content = buf || ""
           await Util.log(logpath, content, session)
         }
       }

package/server/views/app.ejs

@@ -4640,7 +4640,29 @@ const rerenderMenuSection = (container, html) => {
   //        loaded[target.target] = true
   //      }
   }
-  renderSelection()
+
+
+  // Need to strip the plugin= query param when redirected from "ask ai", otherwise it will keep selecting the specified plugin even after closing
+  let pluginQueryStripped = false
+  const stripPluginQueryOnce = () => {
+    if (pluginQueryStripped) return
+    const url = new URL(window.location.href)
+    if (!/\/dev(?:$|\/)/.test(url.pathname)) return
+    if (!url.searchParams.has("plugin")) return
+    url.searchParams.delete("plugin")
+    const qs = url.searchParams.toString()
+    const newUrl = `${url.origin}${url.pathname}${qs ? "?" + qs : ""}${url.hash}`
+    if (window.location.href !== newUrl) {
+      history.replaceState({}, "", newUrl)
+    }
+    const dynBase = "<%-dynamic%>".split("?")[0]
+    const updatedDynamic = qs ? `${dynBase}?${qs}` : dynBase
+    window.__pinokioDynamicUrl = updatedDynamic
+    pluginQueryStripped = true
+  }
+  renderSelection().then(() => {
+    stripPluginQueryOnce()
+  })
   //renderCursor()
   //Reporter()
   <% if (agent === "electron") { %>
@@ -5457,7 +5479,8 @@ const rerenderMenuSection = (container, html) => {
   const try_dynamic = async () => {
     let rendered
     let status
-    const dynamic = await fetch("<%-dynamic%>").then((res) => {
+    const dynamicUrl = window.__pinokioDynamicUrl || "<%-dynamic%>"
+    const dynamic = await fetch(dynamicUrl).then((res) => {
       status = res.status
       return res.text()
     })