@electerm/electerm-react 2.3.166 → 2.3.176

package/client/common/download.jsx

@@ -32,7 +32,7 @@ export default async function download (filename, text) {
     return
   }
   notification.success({
-    message: '',
+    title: '',
     description: (
       <ShowItem
         to={filePath}

package/client/common/error-handler.jsx

@@ -20,7 +20,7 @@ export default (e) => {
     </div>
   )
   notification.error({
-    message: msg,
+    title: msg,
     description,
     duration: 55
   })

package/client/common/fetch.jsx

@@ -30,7 +30,7 @@ export async function handleErr (res) {
   }
   log.debug(text, 'fetch err info')
   notification.error({
-    message: 'error',
+    title: 'error',
     description: (
       <div className='common-err'>
         {text}

package/client/components/main/connection-hopping-warnning.jsx

@@ -27,7 +27,7 @@ export default function ConnectionHoppingWarning (props) {
       return
     }
     notification.info({
-      message: e('connectionHopping'),
+      title: e('connectionHopping'),
       duration: 0,
       placement: 'bottom',
       key: connectionHoppingWarnKey,

package/client/components/quick-commands/qm.styl

@@ -17,16 +17,6 @@
   .qm-list-wrap
     max-height 100px
 
-.fil-keyword
-.fil-label
-  .qm-item
-    color var(--text-disabled)
-  .qm-item
-    &.name-match
-    &.label-match
-      font-weight bold
-      color var(--text)
-
 .qm-search-input
   max-width 200px
 @media (max-width: 500px)

package/client/components/quick-commands/quick-command-item.jsx

@@ -18,17 +18,14 @@ export default class QuickCommandsItem extends PureComponent {
   }
 
   render () {
-    const { name, id, nameMatch, labelMatch, shortcut } = this.props.item
+    const { name, id, shortcut } = this.props.item
     const {
       draggable,
       handleDragOver,
       handleDragStart,
       handleDrop
     } = this.props
-    const cls = classNames('qm-item mg1r mg1b', {
-      'name-match': nameMatch,
-      'label-match': labelMatch
-    })
+    const cls = classNames('qm-item mg1r mg1b')
     const btnProps = {
       className: cls,
       onClick: this.handleSelect,

package/client/components/quick-commands/quick-commands-box.jsx

@@ -129,15 +129,12 @@ export default function QuickCommandsFooterBox (props) {
     )
   }
 
-  function sortArray (array, keyword, labels, qmSortByFrequency) {
-    const sorters = [
-      (obj) => !(keyword && obj.name.toLowerCase().includes(keyword)),
-      (obj) => !labels.some((label) => (obj.labels || []).includes(label))
-    ]
-    if (qmSortByFrequency) {
-      sorters.push((obj) => -(obj.clickCount || 0))
-    }
-    return sortBy(array, sorters)
+  function filterArray (array, keyword, labels) {
+    return array.filter(obj => {
+      const nameMatches = !keyword || obj.name.toLowerCase().includes(keyword)
+      const labelMatches = !labels.length || labels.some((label) => (obj.labels || []).includes(label))
+      return nameMatches && labelMatches
+    })
   }
 
   const {
@@ -156,14 +153,10 @@ export default function QuickCommandsFooterBox (props) {
     return renderNoCmd()
   }
   const keyword0 = keyword.toLowerCase()
-  const filtered = sortArray(all, keyword0, labels, qmSortByFrequency)
-    .map(d => {
-      return {
-        ...d,
-        nameMatch: keyword && d.name.toLowerCase().includes(keyword),
-        labelMatch: labels.some((label) => (d.labels || []).includes(label))
-      }
-    })
+  const filtered = filterArray(all, keyword0, labels)
+  const sorted = qmSortByFrequency
+    ? sortBy(filtered, (obj) => -(obj.clickCount || 0))
+    : filtered
   const sprops = {
     value: labels,
     mode: 'multiple',
@@ -174,11 +167,7 @@ export default function QuickCommandsFooterBox (props) {
   const tp = pinnedQuickCommandBar
     ? 'primary'
     : 'text'
-  const cls = classNames(
-    'qm-list-wrap',
-    { 'fil-label': !!labels.length },
-    { 'fil-keyword': !!keyword }
-  )
+  const cls = classNames('qm-list-wrap')
   const type = qmSortByFrequency ? 'primary' : 'default'
   const w = openedSideBar ? 43 + leftSidebarWidth : 43
   const qmProps = {
@@ -233,7 +222,7 @@ export default function QuickCommandsFooterBox (props) {
           </Space.Compact>
         </Flex>
         <div className={cls}>
-          {filtered.map(renderItem)}
+          {sorted.map(renderItem)}
         </div>
       </div>
     </div>

package/client/components/setting-panel/setting-modal.jsx

@@ -39,7 +39,7 @@ export default auto(function SettingModalWrap (props) {
       shouldConfirmDel: tabsShouldConfirmDel.includes(settingTab),
       list: settingSidebarList
     }
-    const { bookmarks, bookmarkGroups } = store
+    const { bookmarks, bookmarkGroups, widgetInstances } = store
     const formProps = {
       store,
       formData: settingItem,
@@ -51,6 +51,7 @@ export default auto(function SettingModalWrap (props) {
       ]),
       bookmarkGroups,
       bookmarks,
+      widgetInstancesLength: widgetInstances.length,
       serials: store.serials,
       loaddingSerials: store.loaddingSerials
     }

package/client/components/setting-sync/setting-sync-form.jsx

@@ -62,7 +62,7 @@ export default function SyncForm (props) {
     const test = await window.store.testSyncToken(syncType, res.gistId)
     if (!test) {
       return notification.error({
-        message: 'token invalid'
+        title: 'token invalid'
       })
     }
     if (!res.gistId && syncType !== syncTypes.custom && syncType !== syncTypes.cloud) {

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

@@ -981,7 +981,7 @@ export default class Sftp extends Component {
     const np = this.parsePath(type, this.state[nt])
     if (!isValidPath(np)) {
       return notification.warning({
-        message: 'path not valid'
+        title: 'path not valid'
       })
     }
     this.setState({

package/client/components/sftp/sftp.styl

@@ -66,7 +66,7 @@
   .sftp-item
     position absolute
     left 0
-    right 0
+    right 10px
     bottom 0
     top 0
     z-index 1

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

@@ -20,7 +20,7 @@ function handleIgnore () {
 
 function showNotification () {
   notification.info({
-    message: e('loadSshConfigs'),
+    title: e('loadSshConfigs'),
     duration: 0,
     placement: 'bottom',
     key: 'sshConfigNotify',

package/client/components/terminal/terminal.jsx

@@ -1320,7 +1320,7 @@ class Term extends Component {
     }
     this.socketCloseWarning = notification.warning({
       key,
-      message: e('socketCloseTip'),
+      title: e('socketCloseTip'),
       duration: 30,
       description: (
         <div className='pd2y'>

package/client/components/widgets/widget-control.jsx

@@ -5,7 +5,7 @@ import React, { useState } from 'react'
 import WidgetForm from './widget-form'
 import { showMsg } from './widget-notification-with-details'
 
-export default function WidgetControl ({ formData }) {
+export default function WidgetControl ({ formData, widgetInstancesLength }) {
   const [loading, setLoading] = useState(false)
   const widget = formData
   if (!widget.id) {
@@ -16,6 +16,12 @@ export default function WidgetControl ({ formData }) {
     )
   }
 
+  // Check if this widget already has a running instance
+  // widgetInstancesLength is used to trigger re-render when instances change
+  const hasRunningInstance = widgetInstancesLength > 0 && window.store.widgetInstances.some(
+    instance => instance.widgetId === widget.id
+  )
+
   const handleFormSubmit = async (config) => {
     setLoading(true)
     try {
@@ -57,6 +63,7 @@ export default function WidgetControl ({ formData }) {
         widget={widget}
         onSubmit={handleFormSubmit}
         loading={loading}
+        hasRunningInstance={hasRunningInstance}
       />
     </div>
   )

package/client/components/widgets/widget-form.jsx

@@ -2,10 +2,10 @@
  * Widget form component
  */
 import React from 'react'
-import { Form, Input, InputNumber, Switch, Select, Button } from 'antd'
+import { Form, Input, InputNumber, Switch, Select, Button, Tooltip } from 'antd'
 import { formItemLayout, tailFormItemLayout } from '../../common/form-layout'
 
-export default function WidgetForm ({ widget, onSubmit, loading }) {
+export default function WidgetForm ({ widget, onSubmit, loading, hasRunningInstance }) {
   const [form] = Form.useForm()
 
   if (!widget) {
@@ -13,9 +13,10 @@ export default function WidgetForm ({ widget, onSubmit, loading }) {
   }
 
   const { info } = widget
-  const { configs, type } = info
+  const { configs, type, singleInstance } = info
   const isInstanceWidget = type === 'instance'
   const txt = isInstanceWidget ? 'Start widget' : 'Run widget'
+  const isDisabled = loading || (singleInstance && hasRunningInstance)
 
   const handleSubmit = async (values) => {
     onSubmit(values)
@@ -95,14 +96,16 @@ export default function WidgetForm ({ widget, onSubmit, loading }) {
         <Form.Item
           {...tailFormItemLayout}
         >
-          <Button
-            type='primary'
-            htmlType='submit'
-            loading={loading}
-            disabled={loading}
-          >
-            {txt}
-          </Button>
+          <Tooltip title={isDisabled && singleInstance && hasRunningInstance ? 'Already running, only one instance allowed' : ''}>
+            <Button
+              type='primary'
+              htmlType='submit'
+              loading={loading}
+              disabled={isDisabled}
+            >
+              {txt}
+            </Button>
+          </Tooltip>
         </Form.Item>
       </Form>
     </div>

package/client/css/includes/box.styl

@@ -95,10 +95,10 @@ for $i, $index in 5 16 32
   overflow hidden
 
 .overscroll
-  overflow scroll
+  overflow auto
 
 .overscroll-y
-  overflow-y scroll
+  overflow-y auto
 
 .relative
   position relative

package/client/store/common.js

@@ -4,7 +4,7 @@
 
 import handleError from '../common/error-handler'
 import { Modal } from 'antd'
-import { debounce, some, get } from 'lodash-es'
+import { debounce, some, get, pickBy } from 'lodash-es'
 import {
   modals,
   leftSidebarWidthKey,
@@ -219,27 +219,31 @@ export default Store => {
     delete p.name
     delete p.id
     if (type === connectionMap.rdp) {
+      const filtered = pickBy(p.rdp, (value) => value !== undefined && value !== '')
       return {
         ...tab,
-        ...p.rdp
+        ...filtered
       }
     } else if (type === connectionMap.vnc) {
+      const filtered = pickBy(p.vnc, (value) => value !== undefined && value !== '')
       return {
         ...tab,
-        ...p.vnc
+        ...filtered
       }
     } else if (type === connectionMap.telnet) {
+      const filtered = pickBy(p.telnet, (value) => value !== undefined && value !== '')
       return {
         ...tab,
-        ...p.telnet
+        ...filtered
       }
     }
     delete p.rdp
     delete p.vnc
     delete p.telnet
+    const filtered = pickBy(p, (value) => value !== undefined && value !== '')
     return {
       ...tab,
-      ...p
+      ...filtered
     }
   }
   Store.prototype.applyProfileToTabs = function (tab) {

package/client/store/mcp-handler.js

@@ -0,0 +1,640 @@
+/**
+ * MCP (Model Context Protocol) handler for store
+ * Handles IPC requests from the MCP server widget
+ */
+
+import uid from '../common/uid'
+import { settingMap } from '../common/constants'
+
+export default Store => {
+  // Initialize MCP handler - called when MCP widget is started
+  Store.prototype.initMcpHandler = function () {
+    const { ipcOnEvent } = window.pre
+    // Listen for MCP requests from main process
+    ipcOnEvent('mcp-request', (event, request) => {
+      const { requestId, action, data } = request
+      if (action === 'tool-call') {
+        window.store.handleMcpToolCall(requestId, data.toolName, data.args)
+      }
+    })
+  }
+
+  // Handle individual tool calls
+  Store.prototype.handleMcpToolCall = async function (requestId, toolName, args) {
+    const { store } = window
+
+    try {
+      let result
+
+      switch (toolName) {
+        // Bookmark operations
+        case 'list_bookmarks':
+          result = store.mcpListBookmarks(args)
+          break
+        case 'get_bookmark':
+          result = store.mcpGetBookmark(args)
+          break
+        case 'add_bookmark':
+          result = await store.mcpAddBookmark(args)
+          break
+        case 'edit_bookmark':
+          result = store.mcpEditBookmark(args)
+          break
+        case 'delete_bookmark':
+          result = store.mcpDeleteBookmark(args)
+          break
+        case 'open_bookmark':
+          result = store.mcpOpenBookmark(args)
+          break
+
+        // Bookmark group operations
+        case 'list_bookmark_groups':
+          result = store.mcpListBookmarkGroups()
+          break
+        case 'add_bookmark_group':
+          result = await store.mcpAddBookmarkGroup(args)
+          break
+
+        // Quick command operations
+        case 'list_quick_commands':
+          result = store.mcpListQuickCommands()
+          break
+        case 'add_quick_command':
+          result = store.mcpAddQuickCommand(args)
+          break
+        case 'run_quick_command':
+          result = store.mcpRunQuickCommand(args)
+          break
+        case 'delete_quick_command':
+          result = store.mcpDeleteQuickCommand(args)
+          break
+
+        // Tab operations
+        case 'list_tabs':
+          result = store.mcpListTabs()
+          break
+        case 'get_active_tab':
+          result = store.mcpGetActiveTab()
+          break
+        case 'switch_tab':
+          result = store.mcpSwitchTab(args)
+          break
+        case 'close_tab':
+          result = store.mcpCloseTab(args)
+          break
+        case 'reload_tab':
+          result = store.mcpReloadTab(args)
+          break
+        case 'duplicate_tab':
+          result = store.mcpDuplicateTab(args)
+          break
+        case 'open_local_terminal':
+          result = store.mcpOpenLocalTerminal()
+          break
+
+        // Terminal operations
+        case 'send_terminal_command':
+          result = store.mcpSendTerminalCommand(args)
+          break
+        case 'get_terminal_selection':
+          result = store.mcpGetTerminalSelection(args)
+          break
+        case 'get_terminal_output':
+          result = store.mcpGetTerminalOutput(args)
+          break
+
+        // History operations
+        case 'list_history':
+          result = store.mcpListHistory(args)
+          break
+        case 'clear_history':
+          result = store.mcpClearHistory()
+          break
+
+        // Transfer operations
+        case 'list_transfers':
+          result = store.mcpListTransfers()
+          break
+        case 'list_transfer_history':
+          result = store.mcpListTransferHistory(args)
+          break
+
+        // Settings operations
+        case 'get_settings':
+          result = store.mcpGetSettings()
+          break
+        case 'list_terminal_themes':
+          result = store.mcpListTerminalThemes()
+          break
+        case 'list_ui_themes':
+          result = store.mcpListUiThemes()
+          break
+
+        default:
+          throw new Error(`Unknown tool: ${toolName}`)
+      }
+
+      window.api.sendMcpResponse({
+        requestId,
+        result
+      })
+    } catch (error) {
+      window.api.sendMcpResponse({
+        requestId,
+        error: error.message
+      })
+    }
+  }
+
+  // ==================== Bookmark APIs ====================
+
+  Store.prototype.mcpListBookmarks = function (args = {}) {
+    const { store } = window
+    let bookmarks = store.bookmarks
+
+    if (args.groupId) {
+      const group = store.bookmarkGroups.find(g => g.id === args.groupId)
+      if (group && group.bookmarkIds) {
+        const idSet = new Set(group.bookmarkIds)
+        bookmarks = bookmarks.filter(b => idSet.has(b.id))
+      }
+    }
+
+    return bookmarks.map(b => ({
+      id: b.id,
+      title: b.title,
+      host: b.host,
+      port: b.port,
+      username: b.username,
+      type: b.type || 'ssh',
+      color: b.color
+    }))
+  }
+
+  Store.prototype.mcpGetBookmark = function (args) {
+    const { store } = window
+    const bookmark = store.bookmarks.find(b => b.id === args.id)
+    if (!bookmark) {
+      throw new Error(`Bookmark not found: ${args.id}`)
+    }
+    // Return bookmark without sensitive data
+    const { password, passphrase, privateKey, ...safeBookmark } = bookmark
+    return safeBookmark
+  }
+
+  Store.prototype.mcpAddBookmark = async function (args) {
+    const { store } = window
+    const bookmark = {
+      id: uid(),
+      title: args.title,
+      host: args.host || '',
+      port: args.port || 22,
+      username: args.username || '',
+      password: args.password || '',
+      type: args.type || 'local',
+      term: 'xterm-256color',
+      ...args
+    }
+
+    store.addItem(bookmark, settingMap.bookmarks)
+
+    return {
+      success: true,
+      id: bookmark.id,
+      message: `Bookmark "${bookmark.title}" created`
+    }
+  }
+
+  Store.prototype.mcpEditBookmark = function (args) {
+    const { store } = window
+    const { id, updates } = args
+
+    const bookmark = store.bookmarks.find(b => b.id === id)
+    if (!bookmark) {
+      throw new Error(`Bookmark not found: ${id}`)
+    }
+
+    store.editItem(id, updates, settingMap.bookmarks)
+
+    return {
+      success: true,
+      message: `Bookmark "${bookmark.title}" updated`
+    }
+  }
+
+  Store.prototype.mcpDeleteBookmark = function (args) {
+    const { store } = window
+    const bookmark = store.bookmarks.find(b => b.id === args.id)
+    if (!bookmark) {
+      throw new Error(`Bookmark not found: ${args.id}`)
+    }
+
+    store.delItem({ id: args.id }, settingMap.bookmarks)
+
+    return {
+      success: true,
+      message: `Bookmark "${bookmark.title}" deleted`
+    }
+  }
+
+  Store.prototype.mcpOpenBookmark = function (args) {
+    const { store } = window
+    const bookmark = store.bookmarks.find(b => b.id === args.id)
+    if (!bookmark) {
+      throw new Error(`Bookmark not found: ${args.id}`)
+    }
+
+    store.onSelectBookmark(args.id)
+
+    return {
+      success: true,
+      message: `Opened bookmark "${bookmark.title}"`
+    }
+  }
+
+  // ==================== Bookmark Group APIs ====================
+
+  Store.prototype.mcpListBookmarkGroups = function () {
+    const { store } = window
+    return store.bookmarkGroups.map(g => ({
+      id: g.id,
+      title: g.title,
+      level: g.level,
+      bookmarkCount: (g.bookmarkIds || []).length,
+      subgroupCount: (g.bookmarkGroupIds || []).length
+    }))
+  }
+
+  Store.prototype.mcpAddBookmarkGroup = async function (args) {
+    const { store } = window
+    const group = {
+      id: uid(),
+      title: args.title,
+      bookmarkIds: [],
+      bookmarkGroupIds: [],
+      level: args.parentId ? 2 : 1
+    }
+
+    await store.addBookmarkGroup(group)
+
+    return {
+      success: true,
+      id: group.id,
+      message: `Bookmark group "${group.title}" created`
+    }
+  }
+
+  // ==================== Quick Command APIs ====================
+
+  Store.prototype.mcpListQuickCommands = function () {
+    const { store } = window
+    return store.quickCommands.map(q => ({
+      id: q.id,
+      name: q.name,
+      command: q.command,
+      commands: q.commands,
+      inputOnly: q.inputOnly,
+      labels: q.labels
+    }))
+  }
+
+  Store.prototype.mcpAddQuickCommand = function (args) {
+    const { store } = window
+    const qm = {
+      id: uid(),
+      name: args.name,
+      command: args.command,
+      inputOnly: args.inputOnly || false,
+      labels: args.labels || []
+    }
+
+    store.addQuickCommand(qm)
+
+    return {
+      success: true,
+      id: qm.id,
+      message: `Quick command "${qm.name}" created`
+    }
+  }
+
+  Store.prototype.mcpRunQuickCommand = function (args) {
+    const { store } = window
+    const qm = store.quickCommands.find(q => q.id === args.id)
+    if (!qm) {
+      throw new Error(`Quick command not found: ${args.id}`)
+    }
+
+    store.runQuickCommandItem(args.id)
+
+    return {
+      success: true,
+      message: `Executed quick command "${qm.name}"`
+    }
+  }
+
+  Store.prototype.mcpDeleteQuickCommand = function (args) {
+    const { store } = window
+    const qm = store.quickCommands.find(q => q.id === args.id)
+    if (!qm) {
+      throw new Error(`Quick command not found: ${args.id}`)
+    }
+
+    store.delQuickCommand({ id: args.id })
+
+    return {
+      success: true,
+      message: `Deleted quick command "${qm.name}"`
+    }
+  }
+
+  // ==================== Tab APIs ====================
+
+  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
+    }))
+  }
+
+  Store.prototype.mcpGetActiveTab = function () {
+    const { store } = window
+    const tab = store.currentTab
+    if (!tab) {
+      return { activeTabId: null, tab: null }
+    }
+    return {
+      activeTabId: store.activeTabId,
+      tab: {
+        id: tab.id,
+        title: tab.title,
+        host: tab.host,
+        type: tab.type || 'local',
+        status: tab.status
+      }
+    }
+  }
+
+  Store.prototype.mcpSwitchTab = function (args) {
+    const { store } = window
+    const tab = store.tabs.find(t => t.id === args.tabId)
+    if (!tab) {
+      throw new Error(`Tab not found: ${args.tabId}`)
+    }
+
+    store.activeTabId = args.tabId
+    if (tab.batch !== undefined) {
+      store[`activeTabId${tab.batch}`] = args.tabId
+    }
+
+    return {
+      success: true,
+      message: `Switched to tab "${tab.title}"`
+    }
+  }
+
+  Store.prototype.mcpCloseTab = function (args) {
+    const { store } = window
+    const tab = store.tabs.find(t => t.id === args.tabId)
+    if (!tab) {
+      throw new Error(`Tab not found: ${args.tabId}`)
+    }
+
+    store.delTab(args.tabId)
+
+    return {
+      success: true,
+      message: `Closed tab "${tab.title}"`
+    }
+  }
+
+  Store.prototype.mcpReloadTab = function (args) {
+    const { store } = window
+    const tabId = args.tabId || store.activeTabId
+    const tab = store.tabs.find(t => t.id === tabId)
+    if (!tab) {
+      throw new Error(`Tab not found: ${tabId}`)
+    }
+
+    store.reloadTab(tabId)
+
+    return {
+      success: true,
+      message: `Reloaded tab "${tab.title}"`
+    }
+  }
+
+  Store.prototype.mcpDuplicateTab = function (args) {
+    const { store } = window
+    const tab = store.tabs.find(t => t.id === args.tabId)
+    if (!tab) {
+      throw new Error(`Tab not found: ${args.tabId}`)
+    }
+
+    store.duplicateTab(args.tabId)
+
+    return {
+      success: true,
+      message: `Duplicated tab "${tab.title}"`
+    }
+  }
+
+  Store.prototype.mcpOpenLocalTerminal = function () {
+    const { store } = window
+    store.addTab()
+    const newTabId = store.activeTabId
+
+    return {
+      success: true,
+      tabId: newTabId,
+      message: 'Opened new local terminal'
+    }
+  }
+
+  // ==================== Terminal APIs ====================
+
+  Store.prototype.mcpSendTerminalCommand = function (args) {
+    const { store } = window
+    const tabId = args.tabId || store.activeTabId
+    const command = args.command
+
+    if (!tabId) {
+      throw new Error('No active terminal')
+    }
+
+    if (command === undefined || command === null) {
+      throw new Error('No command provided')
+    }
+
+    store.runQuickCommand(command, args.inputOnly || false)
+
+    return {
+      success: true,
+      message: 'Command sent to terminal'
+    }
+  }
+
+  Store.prototype.mcpGetTerminalSelection = function (args) {
+    const { store } = window
+    const { refs } = require('../components/common/ref')
+    const tabId = args.tabId || store.activeTabId
+
+    if (!tabId) {
+      throw new Error('No active terminal')
+    }
+
+    const term = refs.get('term-' + tabId)
+    if (!term || !term.term) {
+      throw new Error('Terminal not found')
+    }
+
+    const selection = term.term.getSelection()
+
+    return {
+      selection: selection || '',
+      tabId
+    }
+  }
+
+  Store.prototype.mcpGetTerminalOutput = function (args) {
+    const { store } = window
+    const { refs } = require('../components/common/ref')
+    const tabId = args.tabId || store.activeTabId
+    const lineCount = args.lines || 50
+
+    if (!tabId) {
+      throw new Error('No active terminal')
+    }
+
+    const term = refs.get('term-' + tabId)
+    if (!term || !term.term) {
+      throw new Error('Terminal not found')
+    }
+
+    const buffer = term.term.buffer.active
+    if (!buffer) {
+      throw new Error('Terminal buffer not available')
+    }
+
+    const cursorY = buffer.cursorY || 0
+    const baseY = buffer.baseY || 0
+    const totalLines = buffer.length || 0
+
+    // Calculate the actual content range
+    // baseY is the scroll offset, cursorY is cursor position in viewport
+    const actualContentEnd = baseY + cursorY + 1
+    const startLine = Math.max(0, actualContentEnd - lineCount)
+    const endLine = Math.min(totalLines, actualContentEnd)
+    const lines = []
+
+    for (let i = startLine; i < endLine; i++) {
+      const line = buffer.getLine(i)
+      if (line) {
+        const text = line.translateToString(true)
+        lines.push(text)
+      }
+    }
+
+    return {
+      output: lines.join('\n'),
+      lineCount: lines.length,
+      cursorY,
+      baseY,
+      tabId
+    }
+  }
+
+  // ==================== History APIs ====================
+
+  Store.prototype.mcpListHistory = function (args = {}) {
+    const { store } = window
+    const limit = args.limit || 50
+    const history = store.history.slice(0, limit)
+
+    return history.map(h => ({
+      id: h.id,
+      title: h.title,
+      host: h.host,
+      type: h.type,
+      time: h.time
+    }))
+  }
+
+  Store.prototype.mcpClearHistory = function () {
+    const { store } = window
+    store.history = []
+
+    return {
+      success: true,
+      message: 'History cleared'
+    }
+  }
+
+  // ==================== Transfer APIs ====================
+
+  Store.prototype.mcpListTransfers = function () {
+    const { store } = window
+    return store.fileTransfers.map(t => ({
+      id: t.id,
+      localPath: t.localPath,
+      remotePath: t.remotePath,
+      type: t.type,
+      percent: t.percent,
+      status: t.status
+    }))
+  }
+
+  Store.prototype.mcpListTransferHistory = function (args = {}) {
+    const { store } = window
+    const limit = args.limit || 50
+    return store.transferHistory.slice(0, limit).map(t => ({
+      id: t.id,
+      localPath: t.localPath,
+      remotePath: t.remotePath,
+      type: t.type,
+      status: t.status,
+      time: t.time
+    }))
+  }
+
+  // ==================== Settings APIs ====================
+
+  Store.prototype.mcpGetSettings = function () {
+    const { store } = window
+    // Return safe settings (no sensitive data)
+    const config = store.config
+    const safeConfig = {
+      theme: config.theme,
+      language: config.language,
+      fontSize: config.fontSize,
+      fontFamily: config.fontFamily,
+      terminalType: config.terminalType,
+      cursorStyle: config.cursorStyle,
+      cursorBlink: config.cursorBlink,
+      scrollback: config.scrollback
+    }
+    return safeConfig
+  }
+
+  Store.prototype.mcpListTerminalThemes = function () {
+    const { store } = window
+    return store.terminalThemes.map(t => ({
+      id: t.id,
+      name: t.name,
+      themeLight: t.themeLight
+    }))
+  }
+
+  Store.prototype.mcpListUiThemes = function () {
+    const { store } = window
+    return (store.uiThemes || []).map(t => ({
+      id: t.id,
+      name: t.name
+    }))
+  }
+}

package/client/store/store.js

@@ -25,6 +25,7 @@ import batchInputHistory from './batch-input-history'
 import transferExtend from './transfer-list'
 import addressBookmarkExtend from './address-bookmark'
 import widgetsExtend from './widgets'
+import mcpHandlerExtend from './mcp-handler'
 import workspaceExtend from './workspace'
 import isColorDark from '../common/is-color-dark'
 import { getReverseColor } from '../common/reverse-color'
@@ -298,6 +299,7 @@ batchInputHistory(Store)
 transferExtend(Store)
 addressBookmarkExtend(Store)
 widgetsExtend(Store)
+mcpHandlerExtend(Store)
 workspaceExtend(Store)
 
 export const StateStore = Store

package/client/store/widgets.js

@@ -16,6 +16,10 @@ export default Store => {
   }
 
   Store.prototype.runWidget = async (widgetId, config) => {
+    // If this is MCP server widget, initialize MCP handler first
+    if (widgetId === 'mcp-server') {
+      window.store.initMcpHandler()
+    }
     return window.pre.runGlobalAsync('runWidget', widgetId, config)
   }
 

package/package.json

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