@electerm/electerm-react 2.3.198 → 2.4.16

package/client/components/sftp/owner-list.js

@@ -29,7 +29,7 @@ const linuxListGroup = 'cat /etc/group'
 
 export async function remoteListUsers (pid) {
   const users = await runCmd(pid, linuxListUser)
-    .catch(log.error)
+    .catch(console.error)
   if (users) {
     return parseNames(users)
   }
@@ -38,7 +38,7 @@ export async function remoteListUsers (pid) {
 
 export async function remoteListGroups (pid) {
   const groups = await runCmd(pid, linuxListGroup)
-    .catch(log.error)
+    .catch(console.error)
   if (groups) {
     return parseNames(groups)
   }
@@ -50,7 +50,7 @@ export async function localListUsers () {
     return {}
   } else if (isMac) {
     const g = await fs.run('dscl . -list /Users UniqueID')
-      .catch(log.error)
+      .catch(console.error)
     return g
       ? g.split('\n')
         .reduce((p, s) => {
@@ -65,7 +65,7 @@ export async function localListUsers () {
         }, {})
       : {}
   } else {
-    const g = await fs.run(linuxListUser).catch(log.error)
+    const g = await fs.run(linuxListUser).catch(console.error)
     return g
       ? parseNames(g)
       : {}
@@ -77,7 +77,7 @@ export async function localListGroups () {
     return {}
   } else if (isMac) {
     const g = await fs.run('dscl . list /Groups PrimaryGroupID')
-      .catch(log.error)
+      .catch(console.error)
     return g
       ? g.split('\n')
         .reduce((p, s) => {
@@ -89,7 +89,7 @@ export async function localListGroups () {
         }, {})
       : {}
   } else {
-    const g = await fs.run(linuxListGroup).catch(log.error)
+    const g = await fs.run(linuxListGroup).catch(console.error)
     return g
       ? parseNames(g)
       : {}

package/client/components/sftp/sftp-entry.jsx

@@ -2,7 +2,9 @@ import { Component } from 'react'
 import { refs } from '../common/ref'
 import generate from '../../common/uid'
 import runIdle from '../../common/run-idle'
-import { Spin, Modal, notification } from 'antd'
+import { Spin } from 'antd'
+import { notification } from '../common/notification'
+import Modal from '../common/modal'
 import clone from '../../common/to-simple-obj'
 import { isEqual, last, isNumber, some, isArray, pick, uniq, debounce } from 'lodash-es'
 import FileSection from './file-item'
@@ -846,8 +848,8 @@ export default class Sftp extends Component {
           sftp,
           realpath
         ).catch(e => {
-          log.debug('seems a bad symbolic link')
-          log.debug(e)
+          console.debug('seems a bad symbolic link')
+          console.debug(e)
           return null
         })
         if (!realFileInfo) {
@@ -981,7 +983,7 @@ export default class Sftp extends Component {
     const np = this.parsePath(type, this.state[nt])
     if (!isValidPath(np)) {
       return notification.warning({
-        title: 'path not valid'
+        message: 'path not valid'
       })
     }
     this.setState({

package/client/components/shortcuts/shortcut-editor.jsx

@@ -1,9 +1,9 @@
 import { PureComponent } from 'react'
 import {
   Button,
-  Input,
-  message
+  Input
 } from 'antd'
+import message from '../common/message'
 import {
   EditFilled,
   CheckOutlined,

package/client/components/ssh-config/ssh-config-load-notify.jsx

@@ -1,5 +1,6 @@
 import React, { useEffect } from 'react'
-import { notification, Button } from 'antd'
+import { Button } from 'antd'
+import { notification } from '../common/notification'
 import * as ls from '../../common/safe-local-storage'
 import {
   sshConfigKey,
@@ -20,7 +21,7 @@ function handleIgnore () {
 
 function showNotification () {
   notification.info({
-    title: e('loadSshConfigs'),
+    message: e('loadSshConfigs'),
     duration: 0,
     placement: 'bottom',
     key: 'sshConfigNotify',

package/client/components/tabs/tab.jsx

@@ -12,9 +12,9 @@ import {
 } from '@ant-design/icons'
 import {
   Tooltip,
-  message,
   Dropdown
 } from 'antd'
+import message from '../common/message'
 import classnames from 'classnames'
 import { pick } from 'lodash-es'
 import Input from '../common/input-auto-focus'

package/client/components/tabs/workspace-save-modal.jsx

@@ -5,7 +5,8 @@
 import React, { useState } from 'react'
 import { auto } from 'manate/react'
 import Modal from '../common/modal'
-import { Input, Select, Button, Space, message, Radio } from 'antd'
+import { Input, Select, Button, Space, Radio } from 'antd'
+import message from '../common/message'
 import { SaveOutlined, EditOutlined } from '@ant-design/icons'
 
 const e = window.translate

package/client/components/terminal/attach-addon-custom.js

@@ -2,7 +2,6 @@
  * customize AttachAddon
  */
 import { AttachAddon } from '@xterm/addon-attach'
-import regEscape from 'escape-string-regexp'
 
 export default class AttachAddonCustom extends AttachAddon {
   constructor (term, socket, isWindowsShell) {
@@ -10,6 +9,80 @@ export default class AttachAddonCustom extends AttachAddon {
     this.term = term
     this.socket = socket
     this.isWindowsShell = isWindowsShell
+    // Output suppression state for shell integration injection
+    this.outputSuppressed = false
+    this.suppressedData = []
+    this.suppressTimeout = null
+    this.onSuppressionEndCallback = null
+    // Track if we've received initial data from the terminal
+    this.hasReceivedInitialData = false
+    this.onInitialDataCallback = null
+  }
+
+  /**
+   * Set callback for when initial data is received
+   * @param {Function} callback - Called when first data arrives
+   */
+  onInitialData = (callback) => {
+    if (this.hasReceivedInitialData) {
+      // Already received, call immediately
+      callback()
+    } else {
+      this.onInitialDataCallback = callback
+    }
+  }
+
+  /**
+   * Start suppressing output - used during shell integration injection
+   * @param {number} timeout - Max time to suppress in ms (safety fallback)
+   * @param {Function} onEnd - Callback when suppression ends
+   */
+  startOutputSuppression = (timeout = 3000, onEnd = null) => {
+    this.outputSuppressed = true
+    this.suppressedData = []
+    this.onSuppressionEndCallback = onEnd
+    // Safety timeout to ensure we always resume
+    this.suppressTimeout = setTimeout(() => {
+      console.warn('[AttachAddon] Output suppression timeout reached, resuming')
+      this.stopOutputSuppression(false)
+    }, timeout)
+  }
+
+  /**
+   * Stop suppressing output and optionally discard buffered data
+   * @param {boolean} discard - If true, discard buffered data; if false, write it to terminal
+   */
+  stopOutputSuppression = (discard = true) => {
+    if (this.suppressTimeout) {
+      clearTimeout(this.suppressTimeout)
+      this.suppressTimeout = null
+    }
+    this.outputSuppressed = false
+
+    if (!discard && this.suppressedData.length > 0) {
+      // Write buffered data to terminal
+      for (const data of this.suppressedData) {
+        this.writeToTerminalDirect(data)
+      }
+    }
+    this.suppressedData = []
+
+    // Call the end callback if set
+    if (this.onSuppressionEndCallback) {
+      const callback = this.onSuppressionEndCallback
+      this.onSuppressionEndCallback = null
+      callback()
+    }
+  }
+
+  /**
+   * Check if we should resume output based on OSC 633 detection
+   * Called when shell integration is detected
+   */
+  onShellIntegrationDetected = () => {
+    if (this.outputSuppressed) {
+      this.stopOutputSuppression(true) // Discard the integration command output
+    }
   }
 
   activate (terminal = this.term) {
@@ -43,11 +116,76 @@ export default class AttachAddonCustom extends AttachAddon {
     }
   }
 
+  /**
+   * Check if data contains OSC 633 shell integration sequences
+   * @param {string} str - Data string to check
+   * @returns {boolean} True if OSC 633 sequence detected
+   */
+  checkForShellIntegration = (str) => {
+    // OSC 633 sequences: ESC]633;X where X is A, B, C, D, E, or P
+    // ESC is character code 27 (0x1b)
+    // Use includes with the actual characters to avoid lint warning
+    const ESC = String.fromCharCode(27)
+    return str.includes(ESC + ']633;')
+  }
+
+  /**
+   * Write directly to terminal, bypassing suppression check
+   * Used for flushing buffered data
+   */
+  writeToTerminalDirect = (data) => {
+    const { term } = this
+    if (term.parent?.onZmodem) {
+      return
+    }
+    if (typeof data === 'string') {
+      return term.write(data)
+    }
+    term?.write(data)
+  }
+
   writeToTerminal = (data) => {
     const { term } = this
     if (term.parent?.onZmodem) {
       return
     }
+
+    // Track initial data arrival
+    if (!this.hasReceivedInitialData) {
+      this.hasReceivedInitialData = true
+      if (this.onInitialDataCallback) {
+        const callback = this.onInitialDataCallback
+        this.onInitialDataCallback = null
+        // Call after a micro-delay to ensure this data is written first
+        setTimeout(callback, 0)
+      }
+    }
+
+    // Check for shell integration in the data (only when suppressing)
+    if (this.outputSuppressed) {
+      let str = data
+      if (typeof data !== 'string') {
+        // Convert to string to check for OSC 633
+        const decoder = this.decoder || new TextDecoder('utf-8')
+        try {
+          str = decoder.decode(data instanceof ArrayBuffer ? data : new Uint8Array(data))
+        } catch (e) {
+          str = ''
+        }
+      }
+
+      // If we detect OSC 633, shell integration is working
+      if (this.checkForShellIntegration(str)) {
+        this.onShellIntegrationDetected()
+        // Don't buffer this - just discard the integration output
+        return
+      }
+
+      // Buffer the data while suppressed
+      this.suppressedData.push(data)
+      return
+    }
+
     if (typeof data === 'string') {
       return term.write(data)
     }
@@ -62,31 +200,9 @@ export default class AttachAddonCustom extends AttachAddon {
     const { term } = this
     term?.parent?.notifyOnData()
     const str = this.decoder.decode(data)
-    if (term?.parent?.props.sftpPathFollowSsh && term?.buffer.active.type !== 'alternate') {
-      const {
-        cwdId
-      } = term
-      const nss = str.split('\r')
-      const nnss = []
-      for (const str1 of nss) {
-        const ns = str1.trim()
-        if (cwdId) {
-          const cwdIdEscaped = regEscape(cwdId)
-          const dirRegex = new RegExp(`${cwdIdEscaped}([^\\n]+?)${cwdIdEscaped}`, 'g')
-          if (ns.match(dirRegex)) {
-            const cwd = dirRegex.exec(ns)[1].trim()
-            if (cwd === '~' || cwd === '%d' || cwd === '%/' || cwd === '$PWD') term.parent.setCwd('')
-            else term.parent.setCwd(cwd)
-            nnss.push(ns.replaceAll(dirRegex, ''))
-          } else nnss.push(str1)
-        } else {
-          nnss.push(str1)
-        }
-      }
-      term.write(nnss.join('\r'))
-    } else {
-      term?.write(str)
-    }
+    // CWD tracking is now handled by shell integration automatically
+    // No need to parse PS1 markers
+    term?.write(str)
   }
 
   sendToServer = (data) => {

package/client/components/terminal/command-tracker-addon.js

@@ -1,83 +1,194 @@
+/**
+ * CommandTrackerAddon - Tracks the current command in the terminal
+ *
+ * This addon uses Shell Integration via OSC 633 escape sequences for reliable
+ * command tracking. The shell emits special sequences that tell us:
+ * - OSC 633 ; A - Prompt started
+ * - OSC 633 ; B - Command input started (ready for typing)
+ * - OSC 633 ; C - Command execution started (output begins)
+ * - OSC 633 ; D ; <exitCode> - Command finished
+ * - OSC 633 ; E ; <command> - The command line being executed
+ * - OSC 633 ; P ; Cwd=<path> - Current working directory
+ *
+ * This properly handles:
+ * - Command history (arrow up/down)
+ * - Tab completion
+ * - Paste operations
+ * - Shell-side editing (readline, vi-mode)
+ * - Multi-line commands
+ * - Any custom prompt
+ */
+
 export class CommandTrackerAddon {
   constructor () {
     this.terminal = undefined
-    this.activeCommand = ''
-    this.currentCommand = ''
-    this.cursorPosition = 0
-    this.timeout = null
-    this.handleKey = this.debounce(this._handleKey, 200) // 10ms debounce
+    this._disposables = []
+
+    // Shell integration state
+    this.currentCommand = '' // Command being typed
+    this.executedCommand = '' // Last executed command
+    this.lastExitCode = null
+    this.cwd = ''
+    this.shellIntegrationActive = false
+
+    // Event callbacks for shell integration events
+    this._onCommandExecuted = null // Called when OSC 633;E is received
+    this._onCwdChanged = null // Called when OSC 633;P;Cwd= is received
   }
 
-  debounce = (func, wait) => {
-    return (...args) => {
-      const later = () => {
-        clearTimeout(this.timeout)
-        func.apply(this, args)
-      }
+  /**
+   * Register callback for when a command is executed (received via OSC 633;E)
+   * @param {function} callback - Called with (command: string)
+   */
+  onCommandExecuted (callback) {
+    this._onCommandExecuted = callback
+  }
 
-      clearTimeout(this.timeout)
-      this.timeout = setTimeout(later, wait)
-    }
+  /**
+   * Register callback for when CWD changes (received via OSC 633;P;Cwd=)
+   * @param {function} callback - Called with (cwd: string)
+   */
+  onCwdChanged (callback) {
+    this._onCwdChanged = callback
   }
 
   activate (terminal) {
     this.terminal = terminal
+
+    // Register OSC 633 handler for shell integration
+    // OSC 633 is the VS Code / modern terminal shell integration protocol
+    if (terminal.parser && terminal.parser.registerOscHandler) {
+      const oscHandler = terminal.parser.registerOscHandler(633, (data) => {
+        return this._handleOsc633(data)
+      })
+      this._disposables.push(oscHandler)
+    }
   }
 
   dispose () {
-    this.term = null
+    this.terminal = null
     if (this._disposables) {
       this._disposables.forEach(d => d.dispose())
       this._disposables.length = 0
     }
-    if (this.timeout) {
-      clearTimeout(this.timeout)
-      this.timeout = null
-    }
   }
 
-  handleData = (data) => {
-    // Handle regular input
-    this.activeCommand = this.activeCommand.slice(0, this.cursorPosition) + data + this.activeCommand.slice(this.cursorPosition)
-    this.cursorPosition += data.length
+  /**
+   * Handle OSC 633 shell integration sequences
+   * @param {string} data - The OSC data after "633;"
+   * @returns {boolean} Whether the sequence was handled
+   */
+  _handleOsc633 (data) {
+    if (!data) return false
+
+    // Parse the sequence: first char is the command type
+    const command = data.charAt(0)
+    const args = data.length > 1 ? data.substring(2) : '' // Skip "X;" part
+
+    switch (command) {
+      case 'A': // Prompt started
+        this.shellIntegrationActive = true
+        // Reset current command when new prompt appears
+        this.currentCommand = ''
+        return true
+
+      case 'B': // Command input started (after prompt)
+        return true
+
+      case 'C': // Command execution started
+        return true
+
+      case 'D': // Command finished
+        // Parse exit code if provided
+        if (args) {
+          this.lastExitCode = parseInt(args, 10)
+        } else {
+          this.lastExitCode = null
+        }
+        return true
+
+      case 'E': // Command line
+        // The actual command being executed
+        this.executedCommand = this._deserializeOscValue(args)
+        this.currentCommand = this.executedCommand
+        // Call the callback if registered
+        if (this._onCommandExecuted && this.executedCommand) {
+          this._onCommandExecuted(this.executedCommand)
+        }
+        return true
+
+      case 'P': // Property (e.g., Cwd=<path>)
+        this._handleProperty(args)
+        return true
+
+      default:
+        return false
+    }
   }
 
-  // This is now our internal handler
-  _handleKey = (e) => {
-    const { key } = e
-    if (e.ctrlKey && key.toLowerCase() === 'c') {
-      this.clearCommand()
-    } else if (key === 'Enter') {
-      // Command executed, reset
-      this.currentCommand = this.activeCommand
-      this.activeCommand = ''
-      this.cursorPosition = 0
-    } else if (key === 'Backspace') {
-      // Handle backspace
-      if (this.cursorPosition > 0) {
-        this.activeCommand = this.activeCommand.slice(0, this.cursorPosition - 1) + this.activeCommand.slice(this.cursorPosition)
-        this.cursorPosition--
-      }
-    } else if (key === 'ArrowLeft') {
-      // Move cursor left
-      if (this.cursorPosition > 0) {
-        this.cursorPosition--
-      }
-    } else if (key === 'ArrowRight') {
-      // Move cursor right
-      if (this.cursorPosition < this.activeCommand.length) {
-        this.cursorPosition++
+  /**
+   * Handle OSC 633 ; P property sequences
+   * @param {string} data - Property data like "Cwd=/path/to/dir"
+   */
+  _handleProperty (data) {
+    const eqIndex = data.indexOf('=')
+    if (eqIndex === -1) return
+
+    const key = data.substring(0, eqIndex)
+    const value = this._deserializeOscValue(data.substring(eqIndex + 1))
+
+    switch (key) {
+      case 'Cwd': {
+        const oldCwd = this.cwd
+        this.cwd = value
+        // Call the callback if registered and CWD actually changed
+        if (this._onCwdChanged && oldCwd !== value) {
+          this._onCwdChanged(value)
+        }
+        break
       }
+      // Add more properties as needed
     }
   }
 
-  clearCommand () {
-    this.activeCommand = ''
-    this.currentCommand = ''
-    this.cursorPosition = 0
+  /**
+   * Deserialize OSC 633 escaped values
+   * Handles: \\ -> \, \x3b -> ;
+   * @param {string} value - Escaped value
+   * @returns {string} Unescaped value
+   */
+  _deserializeOscValue (value) {
+    if (!value) return ''
+    return value
+      .replace(/\\x([0-9a-fA-F]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)))
+      .replace(/\\\\/g, '\\')
   }
 
+  /**
+   * Get the current command (from shell integration)
+   */
   getCurrentCommand () {
-    return this.activeCommand || this.currentCommand
+    return this.executedCommand || this.currentCommand || ''
+  }
+
+  /**
+   * Get the last exit code (if available via shell integration)
+   */
+  getLastExitCode () {
+    return this.lastExitCode
+  }
+
+  /**
+   * Get current working directory (if available via shell integration)
+   */
+  getCwd () {
+    return this.cwd
+  }
+
+  /**
+   * Check if shell integration is active
+   */
+  hasShellIntegration () {
+    return this.shellIntegrationActive
   }
 }