@electerm/electerm-react 5.3.26 → 5.5.9

package/client/components/terminal/automation/strip-ansi.js

@@ -0,0 +1,19 @@
+/* eslint-disable no-control-regex */
+const OSC = /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g
+const CSI = /\x1b\[[0-?]*[ -/]*[@-~]/g
+const OTHER = /\x1b[@-Z\\-_]/g
+
+export const stripAnsi = (s) => {
+  if (!s) {
+    return ''
+  }
+  return s.replace(OSC, '').replace(CSI, '').replace(OTHER, '')
+}
+
+// \r not followed by \n is treated as line break (progress bar scenes)
+export const normalizeCR = (s) => {
+  if (!s) {
+    return ''
+  }
+  return s.replace(/\r\n/g, '\n').replace(/\r/g, '\n')
+}

package/client/components/terminal/automation/trigger-engine.js

@@ -0,0 +1,233 @@
+// Declarative auto-responder engine (ZOC ZocRespond style).
+// Watches a decoded text stream, matches enabled trigger rules and
+// fires their send actions. Trigger rules shape:
+// {
+//   id, name, enabled,
+//   match: { type: 'text' | 'regex', value, caseSensitive },
+//   action: { type: 'send', value },
+//   sendEnter, mode: 'repeat' | 'once' | 'cooldown', cooldownMs
+// }
+import { stripAnsi, normalizeCR } from './strip-ansi.js'
+import { escapeRegExp, expandControlChars } from './keys.js'
+
+function buildRegExp (rule) {
+  const { type = 'text', value = '', caseSensitive = false } = rule.match || {}
+  if (!value) {
+    return null
+  }
+  try {
+    if (type === 'regex') {
+      return new RegExp(value, caseSensitive ? '' : 'i')
+    }
+    return new RegExp(escapeRegExp(value), caseSensitive ? '' : 'i')
+  } catch (e) {
+    return null
+  }
+}
+
+export function validateTriggers (list) {
+  const errors = []
+  if (!Array.isArray(list)) {
+    return ['triggers must be an array']
+  }
+  list.forEach((t, i) => {
+    if (!t || typeof t !== 'object') {
+      errors.push(`#${i}: must be an object`)
+      return
+    }
+    if (!t.match || !t.match.value) {
+      errors.push(`#${i} (${t.name || 'unnamed'}): match.value required`)
+    } else if (t.match.type === 'regex') {
+      try {
+        // eslint-disable-next-line no-new
+        new RegExp(t.match.value)
+      } catch (e) {
+        errors.push(`#${i} (${t.name || 'unnamed'}): invalid regex: ${e.message}`)
+      }
+    }
+    if (t.mode && !['repeat', 'once', 'cooldown'].includes(t.mode)) {
+      errors.push(`#${i} (${t.name || 'unnamed'}): bad mode ${t.mode}`)
+    }
+  })
+  return errors
+}
+
+export default class TriggerEngine {
+  constructor ({ send, maxBuffer = 65536, onFire = null, now = Date.now } = {}) {
+    this.send = send
+    this.maxBuffer = maxBuffer
+    this.onFire = onFire
+    this.now = now
+    this.buf = ''
+    this.base = 0
+    this.rules = []
+    this.reCache = new Map()
+    this.ruleState = new Map()
+  }
+
+  setTriggers (rules) {
+    const nextRules = Array.isArray(rules) ? rules.filter(Boolean) : []
+    const streamEnd = this.base + this.buf.length
+    const nextState = new Map()
+    nextRules.forEach((rule, index) => {
+      const key = this._getRuleKey(rule, index)
+      const signature = this._getRuleSignature(rule)
+      const previous = this.ruleState.get(key)
+      nextState.set(key, previous?.signature === signature
+        ? previous
+        : {
+            signature,
+            startAt: streamEnd,
+            seenEnd: streamEnd,
+            consumedEnd: streamEnd,
+            lastFire: 0,
+            firedOnce: false
+          })
+    })
+    this.rules = nextRules
+    this.ruleState = nextState
+    this.reCache.clear()
+  }
+
+  resetOnce (id = null) {
+    for (const [key, state] of this.ruleState) {
+      if (id == null || key === id) {
+        state.firedOnce = false
+      }
+    }
+  }
+
+  _getRuleKey (rule, index) {
+    return rule.id || `#${index}`
+  }
+
+  _getRuleSignature (rule) {
+    return JSON.stringify([
+      rule.enabled,
+      rule.match?.type,
+      rule.match?.value,
+      rule.match?.caseSensitive,
+      rule.action?.type,
+      rule.action?.value,
+      rule.sendEnter,
+      rule.mode,
+      rule.cooldownMs
+    ])
+  }
+
+  _getRe (rule) {
+    const key = rule.id + '#' + (rule.match?.type || 'text') + '#' + (rule.match?.value || '') + '#' + (rule.match?.caseSensitive ? 's' : 'i')
+    if (!this.reCache.has(key)) {
+      this.reCache.set(key, buildRegExp(rule))
+    }
+    return this.reCache.get(key)
+  }
+
+  push (raw) {
+    if (!raw) {
+      return
+    }
+    const str = normalizeCR(stripAnsi(raw))
+    if (!str) {
+      return
+    }
+    this.buf += str
+    if (this.buf.length > this.maxBuffer) {
+      const over = this.buf.length - this.maxBuffer
+      this.buf = this.buf.slice(over)
+      this.base += over
+    }
+    this._scan()
+  }
+
+  _scan () {
+    const now = this.now()
+    const streamEnd = this.base + this.buf.length
+    this.rules.forEach((rule, index) => {
+      if (!rule || rule.enabled === false) {
+        return
+      }
+      const state = this.ruleState.get(this._getRuleKey(rule, index))
+      if (!state) {
+        return
+      }
+      const mode = rule.mode || 'cooldown'
+      if (mode === 'once' && state.firedOnce) {
+        state.seenEnd = streamEnd
+        return
+      }
+      const re = this._getRe(rule)
+      if (!re) {
+        state.seenEnd = streamEnd
+        return
+      }
+      const gre = new RegExp(re.source, re.flags.includes('i') ? 'gi' : 'g')
+      const previousEnd = state.seenEnd
+      // Literal matches only need enough overlap to bridge the latest chunk.
+      // Regexes can have arbitrary width, so scan the retained window and use
+      // absolute stream positions below to ignore matches already observed.
+      if (rule.match?.type !== 'regex') {
+        const overlap = Math.max(0, (rule.match?.value || '').length - 1)
+        gre.lastIndex = Math.max(0, previousEnd - this.base - overlap)
+      }
+      let m
+      while ((m = gre.exec(this.buf)) !== null) {
+        const matchStart = this.base + m.index
+        const matchEnd = matchStart + m[0].length
+        const isNew = matchEnd > previousEnd &&
+          matchStart >= state.startAt &&
+          matchStart >= state.consumedEnd
+        const cooldown = rule.cooldownMs == null ? 500 : rule.cooldownMs
+        const canFire = mode !== 'cooldown' || now - state.lastFire >= cooldown
+        if (isNew) {
+          // Consume the occurrence even when cooldown suppresses its action.
+          // This prevents a greedy regex rooted in old output from growing
+          // into later chunks and being mistaken for a fresh match.
+          state.consumedEnd = Math.max(state.consumedEnd, matchEnd)
+          if (canFire) {
+            this._fire(rule, m[0], state, now)
+            if (mode === 'once') {
+              break
+            }
+          }
+        }
+        if (m[0].length === 0) {
+          gre.lastIndex++
+        }
+        if (gre.lastIndex > this.buf.length) {
+          break
+        }
+      }
+      state.seenEnd = streamEnd
+    })
+  }
+
+  _fire (rule, matched, state, now) {
+    state.lastFire = now
+    if ((rule.mode || 'cooldown') === 'once') {
+      state.firedOnce = true
+    }
+    try {
+      const action = rule.action || { type: 'send', value: '' }
+      if (action.type === 'send') {
+        const text = expandControlChars(action.value || '')
+        // default: append \r unless text already ends with \r or \n,
+        // unless the user explicitly turned sendEnter off
+        const enter = rule.sendEnter !== false
+        const payload = enter && !/[\r\n]$/.test(text) ? text + '\r' : text
+        this.send?.(payload, { rule, matched })
+      }
+      this.onFire?.({ rule, matched, kind: action.type || 'send' })
+    } catch (e) {
+      console.error('[trigger-engine] fire failed', e)
+    }
+  }
+
+  dispose () {
+    this.buf = ''
+    this.base = 0
+    this.rules = []
+    this.reCache.clear()
+    this.ruleState.clear()
+  }
+}

package/client/components/terminal/automation/trigger-presets.js

@@ -0,0 +1,110 @@
+// Built-in trigger presets users can pick from.
+// send values support \n \t \r \\ \xHH and ^X caret notation.
+export const triggerActionTypes = [
+  { value: 'send', label: 'Send text' },
+  { value: 'notify', label: 'Notify only' }
+]
+
+export const triggerMatchTypes = [
+  { value: 'text', label: 'Text' },
+  { value: 'regex', label: 'RegExp' }
+]
+
+export const triggerModes = [
+  { value: 'cooldown', label: 'Every new match + cooldown' },
+  { value: 'repeat', label: 'Every new match' },
+  { value: 'once', label: 'Once per session' }
+]
+
+export const triggerPresets = [
+  {
+    name: 'Cisco pager: --More--',
+    match: { type: 'text', value: '--More--', caseSensitive: false },
+    action: { type: 'send', value: ' ' },
+    sendEnter: false,
+    mode: 'cooldown',
+    cooldownMs: 500
+  },
+  {
+    name: 'Pager: Press any key to continue',
+    match: { type: 'regex', value: 'press any key|press .* to continue|按任意键', caseSensitive: false },
+    action: { type: 'send', value: ' ' },
+    sendEnter: false,
+    mode: 'cooldown',
+    cooldownMs: 800
+  },
+  {
+    name: 'Confirm: Are you sure? [y/n]',
+    match: { type: 'regex', value: 'are you sure.*\\[y/n\\]|confirm.*\\(y/n\\)', caseSensitive: false },
+    action: { type: 'send', value: 'y' },
+    sendEnter: true,
+    mode: 'cooldown',
+    cooldownMs: 1000
+  },
+  {
+    name: 'Overwrite confirm: Overwrite? (y/n)',
+    match: { type: 'regex', value: 'overwrite.*\\(y/n\\)|是否覆盖', caseSensitive: false },
+    action: { type: 'send', value: 'y' },
+    sendEnter: true,
+    mode: 'cooldown',
+    cooldownMs: 1000
+  },
+  {
+    name: 'sudo password prompt → notify',
+    match: { type: 'regex', value: '\\[sudo\\]\\s*password', caseSensitive: false },
+    action: { type: 'notify', value: '' },
+    sendEnter: false,
+    mode: 'cooldown',
+    cooldownMs: 5000
+  },
+  {
+    name: 'SSH new host key → accept once',
+    match: { type: 'regex', value: 'are you sure you want to continue connecting', caseSensitive: false },
+    action: { type: 'send', value: 'yes' },
+    sendEnter: true,
+    mode: 'once',
+    cooldownMs: 0
+  },
+  {
+    name: 'Telnet login: auto username',
+    match: { type: 'regex', value: 'login[: ]*$|username[: ]*$', caseSensitive: false },
+    action: { type: 'send', value: '' },
+    sendEnter: true,
+    mode: 'cooldown',
+    cooldownMs: 2000
+  },
+  {
+    name: 'Connection closed → notify',
+    match: { type: 'regex', value: 'connection (closed|reset|refused)|lost connection', caseSensitive: false },
+    action: { type: 'notify', value: '' },
+    sendEnter: false,
+    mode: 'cooldown',
+    cooldownMs: 5000
+  }
+]
+
+export function buildTriggerFromPreset (preset, uid) {
+  return {
+    id: uid(),
+    name: preset.name,
+    enabled: true,
+    match: { ...preset.match },
+    action: { ...preset.action },
+    sendEnter: preset.sendEnter !== false,
+    mode: preset.mode || 'cooldown',
+    cooldownMs: preset.cooldownMs == null ? 500 : preset.cooldownMs
+  }
+}
+
+export function buildEmptyTrigger (uid) {
+  return {
+    id: uid(),
+    name: '',
+    enabled: true,
+    match: { type: 'text', value: '', caseSensitive: false },
+    action: { type: 'send', value: '' },
+    sendEnter: true,
+    mode: 'cooldown',
+    cooldownMs: 500
+  }
+}

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

@@ -34,6 +34,25 @@ export class CommandTrackerAddon {
     // 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
+    // Multi-subscriber "a fresh prompt was drawn" signal. Used to pace
+    // scripted input: OSC 633;A means the previous command has finished and
+    // the shell is ready for the next one.
+    this._promptListeners = new Set()
+  }
+
+  /**
+   * Subscribe to "prompt started" (OSC 633;A).
+   * @param {function} callback
+   * @returns {function} unsubscribe
+   */
+  onPrompt (callback) {
+    if (typeof callback !== 'function') {
+      return () => {}
+    }
+    this._promptListeners.add(callback)
+    return () => {
+      this._promptListeners.delete(callback)
+    }
   }
 
   /**
@@ -67,6 +86,9 @@ export class CommandTrackerAddon {
 
   dispose () {
     this.terminal = null
+    this._promptListeners.clear()
+    this._onCommandExecuted = null
+    this._onCwdChanged = null
     if (this._disposables) {
       this._disposables.forEach(d => d.dispose())
       this._disposables.length = 0
@@ -86,11 +108,19 @@ export class CommandTrackerAddon {
     const args = data.length > 1 ? data.substring(2) : '' // Skip "X;" part
 
     switch (command) {
-      case 'A': // Prompt started
+      case 'A': { // Prompt started — the previous command is done
         this.shellIntegrationActive = true
         // Reset current command when new prompt appears
         this.currentCommand = ''
+        for (const cb of this._promptListeners) {
+          try {
+            cb()
+          } catch (e) {
+            console.error('[CommandTracker] prompt listener failed', e)
+          }
+        }
         return true
+      }
 
       case 'B': // Command input started (after prompt)
         return true

package/client/components/terminal/mixins/index.js

@@ -0,0 +1,27 @@
+/**
+ * Terminal mixins.
+ *
+ * `Term` (terminal.jsx) owns a lot of imperative xterm.js wiring. Instead of
+ * one 2000+ line file, its methods are grouped here by concern. Mixin members
+ * are plain functions (not arrow class fields) so they can live in their own
+ * module, and `applyMixins` binds them onto the instance in the constructor.
+ *
+ * Binding matters: these methods are handed out as callbacks (xterm event
+ * listeners, React props, antd menu onClick) and must therefore keep the
+ * "always bound to the instance" behaviour React class fields give.
+ *
+ * A mixin may only export functions. Per-instance mutable state would be
+ * shared by every terminal, so it stays a class field in terminal.jsx.
+ */
+
+export function applyMixins (instance, mixins) {
+  for (const mixin of mixins) {
+    for (const name of Object.keys(mixin)) {
+      const fn = mixin[name]
+      if (typeof fn !== 'function') {
+        throw new Error(`terminal mixin member "${name}" must be a function`)
+      }
+      instance[name] = fn.bind(instance)
+    }
+  }
+}

package/client/components/terminal/mixins/term-attach.js

@@ -0,0 +1,123 @@
+import { debounce } from 'lodash-es'
+import message from '../../common/message'
+import { notification } from '../../common/notification'
+import AttachAddon from '../attach-addon-custom.js'
+import { createTriggerManager } from '../automation/index.js'
+import { isWin } from '../../../common/constants.js'
+import { isUnsafeFilename } from '../../../common/file-drop-utils.js'
+
+/**
+ * Everything that writes to the session: the socket attach addon, encoding,
+ * quick commands / batch input, and the automation trigger manager that runs
+ * on incoming data.
+ */
+export const attachMixin = {
+  async initAttachAddon () {
+    this.attachAddon = new AttachAddon(
+      this.term,
+      this.socket,
+      isWin && !this.isRemote()
+    )
+    this.attachAddon.decoder = new TextDecoder(
+      this.encode || this.props.tab.encode || 'utf-8'
+    )
+    await this.attachAddon.activate(this.term)
+    if (this.osc52Addon) {
+      this.osc52Addon.setSendData(this.attachAddon._sendData.bind(this.attachAddon))
+    }
+    this.initTriggerManager()
+  },
+
+  switchEncoding (encode) {
+    this.encode = encode
+    this.attachAddon.decoder = new TextDecoder(encode)
+  },
+
+  toggleKeepalive () {
+    if (!this.attachAddon) {
+      return false
+    }
+    this._keepaliveEnabled = !this._keepaliveEnabled
+    this.attachAddon.setKeepalive(this._keepaliveEnabled)
+    return this._keepaliveEnabled
+  },
+
+  batchInput (cmd) {
+    this.attachAddon._sendData(cmd + '\r')
+  },
+
+  runQuickCommand (cmd, inputOnly = false) {
+    if (this.term && this.attachAddon) {
+      this.attachAddon._sendData(cmd + (inputOnly ? '' : '\r'))
+      this.term.focus()
+    }
+  },
+
+  cd (p) {
+    if (isUnsafeFilename(p)) {
+      return message.error('File name contains unsafe characters')
+    }
+    const isWinPath = /^[a-zA-Z]:\\/.test(p)
+    this.runQuickCommand(isWinPath ? `cd /d "${p}"` : `cd "${p}"`)
+  },
+
+  initTriggerManager () {
+    this.disposeTriggerManager()
+    if (!this.attachAddon) {
+      return
+    }
+    const attachAddon = this.attachAddon
+    this.triggerManager = createTriggerManager({
+      attachAddon,
+      send: (payload) => {
+        if (payload) {
+          attachAddon._sendData(payload)
+        }
+      },
+      getTriggers: () => {
+        try {
+          return window.store.getEffectiveTriggers(this.props.tab)
+        } catch (e) {
+          return []
+        }
+      },
+      onFire: ({ rule, matched, kind }) => {
+        if (kind === 'notify' && rule) {
+          notification.warning({
+            message: window.translate('triggers') + ': ' + (rule.name || rule.match?.value || ''),
+            description: String(matched || '').slice(-240),
+            duration: 6
+          })
+        }
+      }
+    })
+  },
+
+  refreshTriggers () {
+    try {
+      this.triggerManager?.refresh()
+    } catch (e) {
+      console.debug(e)
+    }
+  },
+
+  disposeTriggerManager () {
+    try {
+      this.triggerManager?.dispose()
+    } catch (e) {
+      console.debug(e)
+    }
+    this.triggerManager = null
+  },
+
+  // Called by attach-addon-custom once per flushed write, so the tab badge
+  // updates without one notification per network chunk.
+  notifyOnData () {
+    if (!this._notifyOnDataDebounced) {
+      this._notifyOnDataDebounced = debounce(() => {
+        window.store.notifyTabOnData(this.props.tab.id)
+      }, 1000)
+    }
+    this._notifyOnDataDebounced()
+  }
+}

package/client/components/terminal/mixins/term-config.jsx

@@ -0,0 +1,84 @@
+import message from '../../common/message'
+import ExternalLink from '../../common/external-link.jsx'
+import { isWin } from '../../../common/constants.js'
+
+/**
+ * Reacting to config changes that cannot be handled by a re-render: they need
+ * the live xterm instance (font/renderer) or the shell integration sequence.
+ */
+export const configMixin = {
+  getValue (props, type, name) {
+    return type === 'glob'
+      ? props.config[name]
+      : props.tab[name] || props.config[name]
+  },
+
+  checkConfigChange (prevProps, props) {
+    for (const k of this.terminalConfigProps) {
+      const { name, type } = k
+      const prev = this.getValue(prevProps, type, name)
+      const curr = this.getValue(props, type, name)
+      if (
+        prev !== curr
+      ) {
+        this.term.options[name] = curr
+        if (['fontFamily', 'fontSize'].includes(name)) {
+          this.onResize()
+        }
+        if (name === 'fontSize') {
+          this.originalFontSize = curr
+          this.setState({ fontSizeChanged: false })
+        }
+      }
+    }
+
+    // Handle renderer type changes (dom <-> webGL) by reloading the
+    // renderer and refreshing the theme so the background color is
+    // correct for the new renderer.
+    if (
+      prevProps.config.rendererType !== props.config.rendererType &&
+      this.term
+    ) {
+      this.reloadWebglRenderer('renderer type change')
+        .then(() => this.applyTerminalTheme())
+        .catch(e => console.error('renderer type change failed', e))
+    }
+
+    // Check for shell integration related config changes
+    const prevShowSuggestions = prevProps.config.showCmdSuggestions
+    const currShowSuggestions = props.config.showCmdSuggestions
+    const prevSftpFollow = prevProps.sftpPathFollowSsh
+    const currSftpFollow = props.sftpPathFollowSsh
+    const prevRestoreTerminal = prevProps.config.restoreTerminalSessionOnReload
+    const currRestoreTerminal = props.config.restoreTerminalSessionOnReload
+
+    if (
+      (!prevShowSuggestions && currShowSuggestions) ||
+      (!prevSftpFollow && currSftpFollow) ||
+      (!prevRestoreTerminal && currRestoreTerminal)
+    ) {
+      // Config was toggled to true, try to inject shell integration if not already done
+      if (this.startupQueue.canInjectShellIntegration() && !this.startupQueue.shellInjected) {
+        this.startupQueue.enqueueShellIntegration(currSftpFollow)
+      } else if (this.startupQueue.shellInjected && currSftpFollow) {
+        this.getCwd()
+      }
+    }
+    if (
+      !prevSftpFollow &&
+      currSftpFollow &&
+      this.isLocal() &&
+      isWin
+    ) {
+      return this.warnSftpFollowUnsupported()
+    }
+  },
+
+  warnSftpFollowUnsupported () {
+    message.warning(
+      <span>
+        Fish shell/windows shell is not supported for SFTP follow SSH path feature. See: <ExternalLink to='https://github.com/electerm/electerm/wiki/Warning-about-sftp-follow-ssh-path-function'>wiki</ExternalLink>
+      </span>
+      , 7)
+  }
+}