@electerm/electerm-react 3.8.15 → 3.9.15

package/client/store/mcp-handler.js

@@ -5,7 +5,7 @@
 
 import uid from '../common/uid'
 import { settingMap } from '../common/constants'
-import { refs } from '../components/common/ref'
+import { refs, refsTabs } from '../components/common/ref'
 import deepCopy from 'json-deep-copy'
 import {
   getLocalFileInfo,
@@ -107,6 +107,9 @@ export default Store => {
         case 'get_terminal_output':
           result = store.mcpGetTerminalOutput(args)
           break
+        case 'wait_for_terminal_idle':
+          result = await store.mcpWaitForTerminalIdle(args)
+          break
 
         // SFTP operations
         case 'sftp_list':
@@ -331,15 +334,18 @@ export default Store => {
 
   Store.prototype.mcpListTabs = function () {
     const { store } = window
-    return store.tabs.map(t => ({
-      id: t.id,
-      title: t.title,
-      host: t.host,
-      type: t.type || 'local',
-      status: t.status,
-      isTransporting: t.isTransporting,
-      batch: t.batch
-    }))
+    return store.tabs.map(t => {
+      return {
+        id: t.id,
+        title: t.title,
+        host: t.host,
+        type: t.type || 'local',
+        status: t.status,
+        isTransporting: t.isTransporting,
+        onData: refsTabs.get('tab-' + t.id)?.state.terminalOnData,
+        batch: t.batch
+      }
+    })
   }
 
   Store.prototype.mcpGetActiveTab = function () {
@@ -527,6 +533,73 @@ export default Store => {
     }
   }
 
+  Store.prototype.mcpWaitForTerminalIdle = async function (args) {
+    const { store } = window
+    const tabId = args.tabId || store.activeTabId
+    const timeout = Math.min(args.timeout || 30000, 120000)
+    const pollInterval = 500
+    const minWait = args.minWait !== undefined ? args.minWait : 1000
+    const lineCountToFetch = args.lines || 50
+
+    if (!tabId) {
+      throw new Error('No active terminal')
+    }
+
+    const start = Date.now()
+
+    // Brief initial wait so the command has time to start producing output
+    if (minWait > 0) {
+      await new Promise(resolve => setTimeout(resolve, minWait))
+    }
+
+    const collectOutput = () => {
+      const term = refs.get('term-' + tabId)
+      if (!term || !term.term) return { output: '', lineCount: 0 }
+      const buffer = term.term.buffer.active
+      if (!buffer) return { output: '', lineCount: 0 }
+      const cursorY = buffer.cursorY || 0
+      const baseY = buffer.baseY || 0
+      const totalLines = buffer.length || 0
+      const actualContentEnd = baseY + cursorY + 1
+      const startLine = Math.max(0, actualContentEnd - lineCountToFetch)
+      const endLine = Math.min(totalLines, actualContentEnd)
+      const lines = []
+      for (let i = startLine; i < endLine; i++) {
+        const line = buffer.getLine(i)
+        if (line) lines.push(line.translateToString(true))
+      }
+      return { output: lines.join('\n'), lineCount: lines.length }
+    }
+
+    // Poll until onData becomes false (4s idle debounce in tab.jsx)
+    while (Date.now() - start < timeout) {
+      const tabRef = refsTabs.get('tab-' + tabId)
+      const onData = tabRef?.state.terminalOnData
+      if (!onData) {
+        const { output, lineCount } = collectOutput()
+        return {
+          tabId,
+          elapsed: Date.now() - start,
+          timedOut: false,
+          output,
+          lineCount
+        }
+      }
+      await new Promise(resolve => setTimeout(resolve, pollInterval))
+    }
+
+    // Timeout reached — return whatever is currently in the buffer
+    const { output, lineCount } = collectOutput()
+    return {
+      tabId,
+      elapsed: Date.now() - start,
+      timedOut: true,
+      message: `Terminal still active after ${timeout}ms`,
+      output,
+      lineCount
+    }
+  }
+
   // ==================== Settings APIs ====================
 
   Store.prototype.mcpGetSettings = function () {

package/client/store/sync.js

@@ -68,11 +68,12 @@ export default (Store) => {
       ).join('####')
     }
     if (type === syncTypes.webdav) {
-      // WebDAV token format: serverUrl####username####password
+      // WebDAV token format: serverUrl####username####password####skipVerify
       const serverUrl = get(window.store.config, 'syncSetting.webdavServerUrl')
       const username = get(window.store.config, 'syncSetting.webdavUsername')
       const password = get(window.store.config, 'syncSetting.webdavPassword')
-      return [serverUrl, username, password].join('####')
+      const skipVerify = get(window.store.config, 'syncSetting.webdavSkipVerify') || false
+      return [serverUrl, username, password, skipVerify].join('####')
     }
     return get(window.store.config, 'syncSetting.' + type + 'AccessToken')
   }

package/client/store/tab.js

@@ -362,6 +362,26 @@ export default Store => {
     store.updateHistory(newTab)
   }
 
+  // Dangerous props that should not be accepted from IPC
+  const dangerousTabProps = [
+    'execLinux',
+    'execMac',
+    'execWindows',
+    'execWindowsArgs',
+    'execMacArgs',
+    'execLinuxArgs',
+    'setEnv',
+    'runScripts',
+    'interactiveValues'
+  ]
+
+  Store.prototype.ipcOpenTab = function (parsed) {
+    const safeTab = Object.fromEntries(
+      Object.entries(parsed).filter(([key]) => !dangerousTabProps.includes(key))
+    )
+    return window.store.addTab(safeTab)
+  }
+
   Store.prototype.clickNextTab = debounce(function () {
     window.store.clickBioTab(1)
   }, 100)
@@ -602,6 +622,20 @@ export default Store => {
     }
   }
 
+  Store.prototype.notifyTabPasswordPrompt = function (tabId) {
+    const tab = refsTabs.get('tab-' + tabId)
+    if (tab) {
+      tab.notifyPasswordPrompt()
+    }
+  }
+
+  Store.prototype.clearTabPasswordPrompt = function (tabId) {
+    const tab = refsTabs.get('tab-' + tabId)
+    if (tab) {
+      tab.clearPasswordPrompt()
+    }
+  }
+
   Store.prototype.remoteList = function (tabId) {
     const sftp = refs.get('sftp-' + tabId)
     if (sftp) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@electerm/electerm-react",
-  "version": "3.8.15",
+  "version": "3.9.15",
   "description": "react components src for electerm",
   "main": "./client/components/main/main.jsx",
   "license": "MIT",

package/client/components/terminal/socket-close-warning.jsx

@@ -1,94 +0,0 @@
-import { useState, useEffect, useRef } from 'react'
-import { Button } from 'antd'
-import { ReloadOutlined } from '@ant-design/icons'
-import { notification } from '../common/notification'
-
-const e = window.translate
-const COUNTDOWN_SECONDS = 3
-
-export function showSocketCloseWarning ({
-  tabId,
-  tab,
-  autoReconnect,
-  delTab,
-  reloadTab
-}) {
-  const key = `open${Date.now()}`
-
-  function closeNotification () {
-    notification.destroy(key)
-  }
-
-  const descriptionNode = (
-    <SocketCloseDescription
-      autoReconnect={autoReconnect}
-      onClose={() => {
-        closeNotification()
-        delTab(tabId)
-      }}
-      onReload={() => {
-        closeNotification()
-        reloadTab({ ...tab, autoReConnect: (tab.autoReConnect || 0) + 1 })
-      }}
-    />
-  )
-
-  notification.warning({
-    key,
-    message: e('socketCloseTip'),
-    duration: autoReconnect ? COUNTDOWN_SECONDS + 2 : 30,
-    description: descriptionNode
-  })
-
-  return { key }
-}
-
-function SocketCloseDescription ({ autoReconnect, onClose, onReload }) {
-  const [countdown, setCountdown] = useState(COUNTDOWN_SECONDS)
-  const timerRef = useRef(null)
-
-  useEffect(() => {
-    if (!autoReconnect) {
-      return
-    }
-    timerRef.current = setInterval(() => {
-      setCountdown(prev => {
-        if (prev <= 1) {
-          clearInterval(timerRef.current)
-          onReload()
-          return 0
-        }
-        return prev - 1
-      })
-    }, 1000)
-
-    return () => {
-      if (timerRef.current) {
-        clearInterval(timerRef.current)
-      }
-    }
-  }, [autoReconnect])
-
-  return (
-    <div className='pd2y'>
-      {autoReconnect && (
-        <div className='pd1b'>
-          {e('autoReconnectTerminal')}: {countdown}s
-        </div>
-      )}
-      <Button
-        className='mg1r'
-        type='primary'
-        onClick={onClose}
-      >
-        {e('close')}
-      </Button>
-      <Button
-        icon={<ReloadOutlined />}
-        onClick={onReload}
-      >
-        {e('reload')}
-      </Button>
-    </div>
-  )
-}