pinokiod 3.209.0 → 3.210.0

package/kernel/api/terminal/index.js

@@ -136,7 +136,10 @@ class Terminal {
       return { files: saved, errors: failures }
     }
 
-    const marker = '[attachment] '
+    const marker = this.buildAttachmentPayload(saved, {
+      shellInstance,
+      params
+    })
     let shellEmitAttempted = false
     let shellEmitSucceeded = false
     if (params && params.id && kernel && kernel.shell && typeof kernel.shell.emit === 'function') {
@@ -173,6 +176,99 @@ class Terminal {
     return { files: saved, errors: failures, shellEmit: shellEmitSucceeded, shellEmitAttempted }
   }
 
+  buildAttachmentPayload(files, context = {}) {
+    const markerPrefix = ''
+    if (!Array.isArray(files) || files.length === 0) {
+      return markerPrefix
+    }
+
+    const shellName = this.resolveShellName(context)
+    const escapedPaths = files
+      .map((file) => {
+        if (!file || typeof file !== 'object') {
+          return null
+        }
+        const rawPath = this.pickBestPath(file)
+        if (!rawPath) {
+          return null
+        }
+        return this.escapePathForShell(shellName, rawPath)
+      })
+      .filter(Boolean)
+
+    if (escapedPaths.length === 0) {
+      return markerPrefix
+    }
+
+    return escapedPaths.join(' ')
+  }
+
+  resolveShellName(context) {
+    if (!context) {
+      return null
+    }
+    const { shellInstance, params } = context
+    if (shellInstance && typeof shellInstance.shell === 'string' && shellInstance.shell.trim()) {
+      return shellInstance.shell.trim()
+    }
+    if (params && typeof params.shell === 'string' && params.shell.trim()) {
+      return params.shell.trim()
+    }
+    return null
+  }
+
+  escapePathForShell(shellName, rawPath) {
+    if (!rawPath || typeof rawPath !== 'string') {
+      return ''
+    }
+    const normalizedPath = rawPath
+    if (!shellName) {
+      return this.escapePosixPath(normalizedPath)
+    }
+    const lowerShell = shellName.toLowerCase()
+    if (lowerShell.includes('powershell') || lowerShell.includes('pwsh')) {
+      return this.escapePowershellPath(normalizedPath)
+    }
+    if (lowerShell.includes('cmd.exe') || lowerShell === 'cmd') {
+      return this.escapeCmdPath(normalizedPath)
+    }
+    return this.escapePosixPath(normalizedPath)
+  }
+
+  pickBestPath(file) {
+    const candidates = [
+      file.cliRelativePath,
+      file.cliPath,
+      file.path,
+      file.displayPath,
+      file.homeRelativePath,
+      file.storedAs,
+      file.originalName,
+      typeof file.name === 'string' ? file.name : null
+    ]
+    for (const candidate of candidates) {
+      if (typeof candidate === 'string') {
+        const trimmed = candidate.trim()
+        if (trimmed.length > 0) {
+          return trimmed
+        }
+      }
+    }
+    return null
+  }
+
+  escapePosixPath(input) {
+    return `'${input.split("'").join("'\\''")}'`
+  }
+
+  escapePowershellPath(input) {
+    return `'${input.split("'").join("''")}'`
+  }
+
+  escapeCmdPath(input) {
+    return `"${input.replace(/(["^%])/g, '^$1')}"`
+  }
+
   resolveShellInstance(params, kernel) {
     if (!params || typeof params.id !== 'string') {
       return null

package/kernel/bracketed_paste_detector.js

@@ -0,0 +1,99 @@
+const { spawn } = require('child_process')
+const os = require('os')
+
+const cache = new Map()
+
+const OK_MARKER = '__PINOKIO_BP_OK__'
+const NO_MARKER = '__PINOKIO_BP_NO__'
+
+function normalizeKey(shell, platform) {
+  return `${platform || os.platform()}::${(shell || '').toLowerCase()}`
+}
+
+function isWindowsShell(shell) {
+  const name = (shell || '').toLowerCase()
+  return name.includes('cmd.exe') || name === 'cmd' || name.includes('powershell') || name.includes('pwsh')
+}
+
+function isBash(shell) {
+  return (shell || '').toLowerCase().includes('bash')
+}
+
+function isZsh(shell) {
+  return (shell || '').toLowerCase().includes('zsh')
+}
+
+function runProbe(shell, args, script) {
+  return new Promise((resolve) => {
+    let stdout = ''
+    const child = spawn(shell, [...args, script], {
+      stdio: ['ignore', 'pipe', 'ignore']
+    })
+    child.stdout.setEncoding('utf8')
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk
+    })
+    child.on('error', () => resolve(null))
+    child.on('close', () => resolve(stdout))
+  })
+}
+
+async function detect(shell, platform = os.platform()) {
+  const key = normalizeKey(shell, platform)
+  if (cache.has(key)) {
+    return cache.get(key)
+  }
+
+  let result
+  try {
+    result = await runDetection(shell, platform)
+  } catch (_) {
+    result = null
+  }
+  if (result === null) {
+    result = true
+  }
+  cache.set(key, result)
+  return result
+}
+
+async function runDetection(shell, platform) {
+  if (!shell) {
+    return true
+  }
+  if (isWindowsShell(shell)) {
+    return false
+  }
+
+  if (isBash(shell)) {
+    const script = `if bind -v 2>/dev/null | grep -q 'enable-bracketed-paste'; then bind 'set enable-bracketed-paste on' >/dev/null 2>&1; printf '${OK_MARKER}\n'; else printf '${NO_MARKER}\n'; fi`
+    const output = await runProbe(shell, ['--noprofile', '--norc', '-ic'], script)
+    return parseProbeOutput(output)
+  }
+
+  if (isZsh(shell)) {
+    const script = `if setopt -q bracketed-paste 2>/dev/null; then printf '${OK_MARKER}\n'; exit 0; fi; if setopt bracketed-paste 2>/dev/null; then printf '${OK_MARKER}\n'; exit 0; fi; printf '${NO_MARKER}\n'`
+    const output = await runProbe(shell, ['-f', '-c'], script)
+    return parseProbeOutput(output)
+  }
+
+  // For other shells assume supported unless clearly Windows-only.
+  return true
+}
+
+function parseProbeOutput(output) {
+  if (typeof output !== 'string') {
+    return null
+  }
+  if (output.includes(OK_MARKER)) {
+    return true
+  }
+  if (output.includes(NO_MARKER)) {
+    return false
+  }
+  return null
+}
+
+module.exports = {
+  detect
+}

package/kernel/environment.js

@@ -613,8 +613,8 @@ const init = async (options, kernel) => {
 
     const entriesToEnsure = [
       "ENVIRONMENT",
-      ".*",
-      "~*",
+//      ".*",
+//      "~*",
       "/logs/",
       "/cache/",
       "/AGENTS.md",

package/kernel/shell.js

@@ -40,6 +40,13 @@ class Shell {
     this.platform = os.platform()
     this.logs = {}
     this.shell = this.platform === 'win32' ? 'cmd.exe' : 'bash';
+    this.supportsBracketedPaste = this.computeBracketedPasteSupport(this.shell)
+    if (this.kernel && this.kernel.bracketedPasteSupport) {
+      const cached = this.kernel.bracketedPasteSupport[(this.shell || '').toLowerCase()]
+      if (typeof cached === 'boolean') {
+        this.supportsBracketedPaste = cached
+      }
+    }
     this.decsyncBuffer = ''
 
     // Windows: /D => ignore AutoRun Registry Key
@@ -276,6 +283,12 @@ class Shell {
     this.EOL = os.EOL
     if (this.params.shell) {
       this.shell = this.params.shell
+      const normalizedShell = (this.shell || '').toLowerCase()
+      if (this.kernel && this.kernel.bracketedPasteSupport && typeof this.kernel.bracketedPasteSupport[normalizedShell] === 'boolean') {
+        this.supportsBracketedPaste = this.kernel.bracketedPasteSupport[normalizedShell]
+      } else {
+        this.supportsBracketedPaste = this.computeBracketedPasteSupport(this.shell)
+      }
       if (/bash/i.test(this.shell)) {
         this.args = ["--noprofile", "--norc"]
         //this.args = [ "--login", "-i"]
@@ -579,6 +592,19 @@ class Shell {
     const regex = new RegExp(pattern, 'gi')
     return str.replaceAll(regex, '');
   }
+  computeBracketedPasteSupport(shellName) {
+    const name = (shellName || '').toLowerCase()
+    if (!name) {
+      return true
+    }
+    if (name.includes('cmd.exe') || name === 'cmd') {
+      return false
+    }
+    if (name.includes('powershell') || name.includes('pwsh')) {
+      return false
+    }
+    return true
+  }
   exists(abspath) {
     return new Promise(r=>fs.access(abspath, fs.constants.F_OK, e => r(!e)))
   }

package/kernel/shells.js

@@ -9,10 +9,12 @@ const {
 
 const path = require('path')
 const Shell = require("./shell")
+const { detect: detectBracketedPasteSupport } = require('./bracketed_paste_detector')
 class Shells {
   constructor(kernel) {
     this.kernel = kernel
     this.shells = []
+    this.bracketedPasteDetections = new Map()
 
   }
   /*
@@ -40,6 +42,14 @@ class Shells {
       env: this.kernel.bin.envs({}),
     })
 
+    await this.ensureBracketedPasteSupport(sh.shell)
+    if (this.kernel.bracketedPasteSupport) {
+      const cached = this.kernel.bracketedPasteSupport[(sh.shell || '').toLowerCase()]
+      if (typeof cached === 'boolean') {
+        sh.supportsBracketedPaste = cached
+      }
+    }
+
     this.kernel.envs = sh.env
     // also set the uppercase variables if they're not set
     for(let key in sh.env) {
@@ -67,6 +77,44 @@ class Shells {
       }
     })
   }
+  async ensureBracketedPasteSupport(shellName) {
+    if (!shellName) {
+      return
+    }
+    const lower = (shellName || '').toLowerCase()
+    if (!lower) {
+      return
+    }
+    if (!this.kernel.bracketedPasteSupport) {
+      this.kernel.bracketedPasteSupport = {}
+    }
+    if (Object.prototype.hasOwnProperty.call(this.kernel.bracketedPasteSupport, lower)) {
+      return this.kernel.bracketedPasteSupport[lower]
+    }
+    if (this.bracketedPasteDetections.has(lower)) {
+      return this.bracketedPasteDetections.get(lower)
+    }
+    const fallback = !(lower.includes('cmd.exe') || lower === 'cmd' || lower.includes('powershell') || lower.includes('pwsh'))
+    const detectionPromise = detectBracketedPasteSupport(shellName, this.kernel.platform || os.platform())
+      .then((support) => {
+        const value = typeof support === 'boolean' ? support : fallback
+        this.kernel.bracketedPasteSupport[lower] = value
+        return value
+      })
+      .catch((error) => {
+        console.warn('[shells.ensureBracketedPasteSupport] detection failed', {
+          shell: shellName,
+          error: error && error.message ? error.message : error
+        })
+        this.kernel.bracketedPasteSupport[lower] = fallback
+        return fallback
+      })
+      .finally(() => {
+        this.bracketedPasteDetections.delete(lower)
+      })
+    this.bracketedPasteDetections.set(lower, detectionPromise)
+    return detectionPromise
+  }
   async launch(params, options, ondata) {
     // if array, duplicate the action
     if (Array.isArray(params.message)) {
@@ -112,6 +160,9 @@ class Shells {
     let exec_path = (params.path ? params.path : ".")                         // use the current path if not specified
     let cwd = (options && options.cwd ? options.cwd : this.kernel.homedir)   // if cwd exists, use it. Otherwise the cwd is pinokio home folder (~/pinokio)              
     params.path = this.kernel.api.resolvePath(cwd, exec_path)
+
+    const plannedShell = params.shell || (this.kernel.platform === 'win32' ? 'cmd.exe' : 'bash')
+    await this.ensureBracketedPasteSupport(plannedShell)
     let sh = new Shell(this.kernel)
     if (options) {
       params.group = options.group  // set group
@@ -387,9 +438,13 @@ class Shells {
     let session = this.get(params.id)
     if (session) {
       if (params.paste) {
-        //session.emit("\x1b[?2004h\x1b[200~" + params.emit+ "\x1b[201~")
-        session.emit("\x1b[200~" + params.emit+ "\x1b[201~")
-        //session.emit(params.emit)
+        const payload = params.emit != null ? String(params.emit) : ''
+        if (session.supportsBracketedPaste !== false) {
+          //session.emit("\x1b[?2004h\x1b[200~" + params.emit+ "\x1b[201~")
+          session.emit("\x1b[200~" + payload + "\x1b[201~")
+        } else {
+          session.emit(payload)
+        }
       } else {
         session.emit(params.emit)
       }

package/package.json

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