@electerm/electerm-react 3.15.0 → 3.15.32

package/client/common/default-setting.js

@@ -64,6 +64,7 @@ export default {
   ],
   hideIP: false,
   dataSyncSelected: 'all',
+  nameAI: '',
   baseURLAI: 'https://api.atlascloud.ai/v1',
   modelAI: 'deepseek-chat',
   roleAI: '终端专家,提供不同系统下命令,简要解释用法,用markdown格式',

package/client/components/ai/agent-tools.js

@@ -31,7 +31,7 @@ export const agentTools = [
     type: 'function',
     function: {
       name: 'send_terminal_command',
-      description: 'Send a command to a terminal tab and wait for it to finish. Returns the command output.',
+      description: 'Send a command to a terminal tab and wait for it to finish. Returns the command output. For long-running commands (builds, deployments, installations), use run_background_command instead to avoid timeouts.',
       parameters: {
         type: 'object',
         properties: {
@@ -334,6 +334,114 @@ export const agentTools = [
         properties: {}
       }
     }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'get_terminal_status',
+      description: 'Check terminal status: running (actively receiving data), idle, or password prompt. Returns last 20 lines of output. Lightweight, non-blocking.',
+      parameters: {
+        type: 'object',
+        properties: {
+          tabId: {
+            type: 'string',
+            description: 'Tab ID. Omit for active terminal.'
+          }
+        }
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'cancel_terminal_command',
+      description: 'Cancel the running command in a terminal by sending Ctrl+C.',
+      parameters: {
+        type: 'object',
+        properties: {
+          tabId: {
+            type: 'string',
+            description: 'Tab ID. Omit for active terminal.'
+          }
+        }
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'run_background_command',
+      description: 'Run a command in the background using nohup. The terminal is freed immediately. Returns a taskId for monitoring. Use get_background_task_status and get_background_task_log to check progress.',
+      parameters: {
+        type: 'object',
+        properties: {
+          command: {
+            type: 'string',
+            description: 'The shell command to run in the background.'
+          },
+          tabId: {
+            type: 'string',
+            description: 'Tab ID. Omit for active terminal.'
+          }
+        },
+        required: ['command']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'get_background_task_status',
+      description: 'Check if a background task is running, completed (with exit code), or unknown.',
+      parameters: {
+        type: 'object',
+        properties: {
+          taskId: {
+            type: 'string',
+            description: 'Task ID from run_background_command.'
+          }
+        },
+        required: ['taskId']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'get_background_task_log',
+      description: 'Read the output log of a background task. Returns the last N lines.',
+      parameters: {
+        type: 'object',
+        properties: {
+          taskId: {
+            type: 'string',
+            description: 'Task ID from run_background_command.'
+          },
+          lines: {
+            type: 'number',
+            description: 'Number of recent lines to read (default 100).'
+          }
+        },
+        required: ['taskId']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'cancel_background_task',
+      description: 'Cancel a running background task by killing its process.',
+      parameters: {
+        type: 'object',
+        properties: {
+          taskId: {
+            type: 'string',
+            description: 'Task ID from run_background_command.'
+          }
+        },
+        required: ['taskId']
+      }
+    }
   }
 ]
 
@@ -391,6 +499,18 @@ export async function executeToolCall (toolName, args) {
       return JSON.stringify(store.mcpSftpTransferList())
     case 'sftp_transfer_history':
       return JSON.stringify(store.mcpSftpTransferHistory())
+    case 'get_terminal_status':
+      return JSON.stringify(store.mcpGetTerminalStatus(args))
+    case 'cancel_terminal_command':
+      return JSON.stringify(store.mcpCancelTerminalCommand(args))
+    case 'run_background_command':
+      return JSON.stringify(store.mcpRunBackgroundCommand(args))
+    case 'get_background_task_status':
+      return JSON.stringify(await store.mcpGetBackgroundTaskStatus(args))
+    case 'get_background_task_log':
+      return JSON.stringify(await store.mcpGetBackgroundTaskLog(args))
+    case 'cancel_background_task':
+      return JSON.stringify(await store.mcpCancelBackgroundTask(args))
     default:
       throw new Error(`Unknown agent tool: ${toolName}`)
   }

package/client/components/ai/ai-chat-history-item.jsx

@@ -22,6 +22,7 @@ export default function AIChatHistoryItem ({ item }) {
   const {
     prompt,
     sessionId,
+    nameAI,
     modelAI,
     roleAI,
     baseURLAI,
@@ -190,6 +191,11 @@ export default function AIChatHistoryItem ({ item }) {
   function renderTitle () {
     return (
       <div>
+        {nameAI && (
+          <p>
+            <b>Name:</b> {nameAI}
+          </p>
+        )}
         <p>
           <b>Model:</b> {modelAI}
         </p>

package/client/components/ai/ai-chat.jsx

@@ -52,6 +52,7 @@ export default function AIChat (props) {
       mode,
       toolCalls: [],
       ...pick(props.config, [
+        'nameAI',
         'modelAI',
         'roleAI',
         'baseURLAI',

package/client/components/ai/ai-config-props.js

@@ -1,4 +1,5 @@
 export const aiConfigsArr = [
+  'nameAI',
   'baseURLAI',
   'modelAI',
   'roleAI',

package/client/components/ai/ai-config.jsx

@@ -94,10 +94,13 @@ export default function AIConfigForm ({ initialValues, onSubmit, showAIConfig })
 
   function renderHistoryItem (item) {
     if (!item || typeof item !== 'object') return { label: 'Unknown', title: 'Unknown' }
+    const name = item.nameAI || ''
     const model = item.modelAI || 'Default Model'
     const rolePrefix = item.roleAI ? item.roleAI.substring(0, 15) + '...' : ''
-    const label = `[${model}] ${rolePrefix}`
-    const title = `Model: ${item.modelAI}\nRole: ${item.roleAI}\nURL: ${item.baseURLAI}`
+    const label = name || `[${model}] ${rolePrefix}`
+    const title = name
+      ? `${name}\nModel: ${item.modelAI}\nURL: ${item.baseURLAI}`
+      : `Model: ${item.modelAI}\nRole: ${item.roleAI}\nURL: ${item.baseURLAI}`
     return { label, title }
   }
 
@@ -131,6 +134,14 @@ export default function AIConfigForm ({ initialValues, onSubmit, showAIConfig })
         layout='vertical'
         className='ai-config-form'
       >
+        <Form.Item
+          label='Name'
+          name='nameAI'
+        >
+          <Input
+            placeholder='e.g. DeepSeek Relay, Local Ollama (optional)'
+          />
+        </Form.Item>
         <Form.Item label={renderApiUrlLabel()} required>
           <Space.Compact className='width-100'>
             <Form.Item

package/client/components/ai/ai-output.jsx

@@ -10,7 +10,9 @@ const e = window.translate
 export default function AIOutput ({ item }) {
   const {
     response,
-    baseURLAI
+    baseURLAI,
+    nameAI,
+    modelAI
   } = item
   if (!response) {
     return null
@@ -82,10 +84,12 @@ export default function AIOutput ({ item }) {
     if (!brand) {
       return null
     }
+    const nameLabel = nameAI || modelAI
+    const label = nameLabel ? `${brand}:${nameLabel}` : brand
     return (
       <div className='pd1y'>
         <Link to={brandUrl}>
-          <Tag>{brand}</Tag>
+          <Tag>{label}</Tag>
         </Link>
       </div>
     )

package/client/components/sftp/file-item.jsx

@@ -697,11 +697,22 @@ export default class FileSection extends React.Component {
     const {
       path, name
     } = this.state.file
-    const rp = path ? resolve(path, name) : this.props[`${this.props.type}Path`]
+    let rp = path ? resolve(path, name) : this.props[`${this.props.type}Path`]
+    if (this.props.type === typeMap.remote) {
+      rp = this.convertSftpPathToTerminalPath(rp)
+    }
     this.props.tab.pane = paneMap.terminal
     refs.get('term-' + this.props.tab.id)?.cd(rp)
   }
 
+  convertSftpPathToTerminalPath = (p) => {
+    const m = p.match(/^\/([a-zA-Z]:)(.*)$/)
+    if (m) {
+      return m[1] + m[2].replace(/\//g, '\\')
+    }
+    return p
+  }
+
   fetchEditorText = async (path, type) => {
     // const sftp = sftpFunc()
     const text = typeMap.remote === type

package/client/components/terminal/osc52-addon.js

@@ -0,0 +1,147 @@
+/**
+ * Osc52Addon - Handles OSC 52 clipboard escape sequences
+ *
+ * OSC 52 allows terminal programs (TUI apps like vim, tmux, opencode, etc.)
+ * to copy and paste text via the system clipboard.
+ *
+ * Format: ESC ] 52 ; Pc ; Pd BEL (or ST)
+ *   Pc = clipboard selection: c (clipboard), p (primary), s (secondary)
+ *   Pd = base64-encoded content, or "?" to read
+ *
+ * Write request: ESC ] 52 ; c ; <base64data> BEL
+ *   -> decodes base64 and writes to system clipboard
+ *
+ * Read request: ESC ] 52 ; c ; ? BEL
+ *   -> reads system clipboard, encodes base64, sends response
+ */
+
+export class Osc52Addon {
+  constructor () {
+    this.terminal = undefined
+    this._disposables = []
+    this._sendData = null
+  }
+
+  /**
+   * Set the function used to send data back to the PTY
+   * @param {function} sendDataFn - function(string) to send data to server
+   */
+  setSendData (sendDataFn) {
+    this._sendData = sendDataFn
+  }
+
+  activate (terminal) {
+    this.terminal = terminal
+
+    if (terminal.parser && terminal.parser.registerOscHandler) {
+      const oscHandler = terminal.parser.registerOscHandler(52, (data) => {
+        return this._handleOsc52(data)
+      })
+      this._disposables.push(oscHandler)
+    }
+  }
+
+  dispose () {
+    this.terminal = null
+    if (this._disposables) {
+      this._disposables.forEach(d => d.dispose())
+      this._disposables.length = 0
+    }
+  }
+
+  /**
+   * Handle OSC 52 clipboard sequence
+   * @param {string} data - The OSC data after "52;"
+   * @returns {boolean} Whether the sequence was handled
+   */
+  _handleOsc52 (data) {
+    if (!data) return false
+
+    // Parse: Pc;Pd where Pc is selection target and Pd is payload
+    const semicolonIdx = data.indexOf(';')
+    if (semicolonIdx === -1) return false
+
+    const target = data.substring(0, semicolonIdx)
+    const payload = data.substring(semicolonIdx + 1)
+
+    // Only handle clipboard target ('c'), also accept 'c' among multiple targets
+    if (!target.includes('c')) return false
+
+    if (payload === '?') {
+      // Read request - send clipboard content back
+      return this._handleReadRequest()
+    }
+
+    // Write request - decode and write to clipboard
+    return this._handleWriteRequest(payload)
+  }
+
+  /**
+   * Handle clipboard read request (ESC]52;c;? BEL)
+   * Reads system clipboard and sends response back to the terminal
+   */
+  _handleReadRequest () {
+    try {
+      const text = window.pre.readClipboard()
+      const base64 = text ? this._encodeBase64(text) : ''
+      this._sendResponse(base64)
+    } catch (e) {
+      console.error('OSC 52 clipboard read failed:', e)
+      this._sendResponse('')
+    }
+    return true
+  }
+
+  /**
+   * Handle clipboard write request (ESC]52;c;<base64> BEL)
+   * Decodes base64 content and writes to system clipboard
+   */
+  _handleWriteRequest (base64Data) {
+    try {
+      const text = this._decodeBase64(base64Data)
+      if (text) {
+        window.pre.writeClipboard(text)
+      }
+    } catch (e) {
+      console.error('OSC 52 clipboard write failed:', e)
+    }
+    return true
+  }
+
+  /**
+   * Send OSC 52 response back to the terminal (for read requests)
+   * @param {string} base64Data - base64-encoded clipboard content
+   */
+  _sendResponse (base64Data) {
+    if (!this._sendData) return
+    // Response format: ESC ] 52 ; c ; <base64> BEL
+    const response = `\x1b]52;c;${base64Data}\x07`
+    this._sendData(response)
+  }
+
+  /**
+   * Encode a string to base64 (handles UTF-8 properly)
+   */
+  _encodeBase64 (str) {
+    const encoder = new TextEncoder()
+    const bytes = encoder.encode(str)
+    let binary = ''
+    for (let i = 0; i < bytes.length; i++) {
+      binary += String.fromCharCode(bytes[i])
+    }
+    return btoa(binary)
+  }
+
+  /**
+   * Decode a base64 string (handles UTF-8 properly)
+   */
+  _decodeBase64 (base64) {
+    const binary = atob(base64)
+    const bytes = new Uint8Array(binary.length)
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i)
+    }
+    const decoder = new TextDecoder()
+    return decoder.decode(bytes)
+  }
+}

package/client/components/terminal/terminal.jsx

@@ -38,6 +38,7 @@ import { KeywordHighlighterAddon } from './highlight-addon.js'
 import { getFilePath, isUnsafeFilename } from '../../common/file-drop-utils.js'
 import { getFolderFromFilePath } from '../sftp/file-read.js'
 import { CommandTrackerAddon } from './command-tracker-addon.js'
+import { Osc52Addon } from './osc52-addon.js'
 import AIIcon from '../icons/ai-icon.jsx'
 import {
   getShellIntegrationCommand,
@@ -204,6 +205,9 @@ class Term extends Component {
       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))
+    }
   }
 
   getValue = (props, type, name) => {
@@ -391,7 +395,8 @@ class Term extends Component {
     if (isUnsafeFilename(p)) {
       return message.error('File name contains unsafe characters')
     }
-    this.runQuickCommand(`cd "${p}"`)
+    const isWinPath = /^[a-zA-Z]:\\/.test(p)
+    this.runQuickCommand(isWinPath ? `cd /d "${p}"` : `cd "${p}"`)
   }
 
   onDrop = e => {
@@ -1125,6 +1130,8 @@ class Term extends Component {
     term.loadAddon(this.fitAddon)
     term.loadAddon(this.searchAddon)
     term.loadAddon(this.cmdAddon)
+    this.osc52Addon = new Osc52Addon()
+    term.loadAddon(this.osc52Addon)
     if (tab.enableTerminalImage) {
       const ImageAddon = await loadImageAddon()
       this.imageAddon = new ImageAddon({

package/client/components/terminal/xmodem-client.js

@@ -66,6 +66,68 @@ export class XmodemClient extends TransferClientBase {
       case 'session-error':
         this.onError(msg.error)
         break
+      case 'auto-trigger-receive':
+        this.handleAutoReceive(msg.name)
+        break
+      case 'auto-trigger-send':
+        this.handleAutoSend()
+        break
+    }
+  }
+
+  /**
+   * Auto-triggered: device is sending a file, electerm should receive it.
+   * Opens save folder dialog then starts xmodem receive.
+   * @param {string} fileName - Original filename from the device
+   */
+  async handleAutoReceive (fileName) {
+    if (this.isActive) return
+
+    this.isActive = true
+    this.writeBanner('RECEIVE', null)
+
+    const savePath = await this.openSaveFolderSelect()
+    if (savePath) {
+      this.savePath = savePath
+      this.sendToServer({
+        event: 'start-receive'
+      })
+      this.sendToServer({
+        event: 'set-save-path',
+        path: savePath,
+        name: fileName
+      })
+    } else {
+      this.isActive = false
+      this.writeToTerminal('\r\n\x1b[33mXMODEM Receive cancelled\x1b[0m\r\n')
+    }
+  }
+
+  /**
+   * Auto-triggered: device wants to receive a file, electerm should send it.
+   * Opens file select dialog then starts xmodem send.
+   */
+  async handleAutoSend () {
+    if (this.isActive) return
+
+    this.isActive = true
+    this.writeBanner('SEND', null)
+
+    const files = await this.openFileSelect({
+      title: 'Choose file to send via XMODEM',
+      message: 'Choose file to send via XMODEM'
+    })
+    if (files && files.length > 0) {
+      this.sendToServer({
+        event: 'start-send'
+      })
+      this.sendToServer({
+        event: 'send-files',
+        files
+      })
+    } else {
+      this.isActive = false
+      this.writeToTerminal('\r\n\x1b[33mXMODEM Send cancelled\x1b[0m\r\n')
     }
   }
 

package/client/store/common.js

@@ -298,7 +298,7 @@ export default Store => {
   }
 
   Store.prototype.aiConfigMissing = function () {
-    return aiConfigsArr.filter(k => k !== 'apiKeyAI' && k !== 'proxyAI').some(k => !window.store.config[k])
+    return aiConfigsArr.filter(k => k !== 'apiKeyAI' && k !== 'proxyAI' && k !== 'nameAI').some(k => !window.store.config[k])
   }
 
   Store.prototype.clearHistory = function () {

package/client/store/load-data.js

@@ -52,6 +52,20 @@ export async function addTabFromCommandLine (store, opts) {
   if (isHelp) {
     return store.openAbout(infoTabs.cmd)
   }
+  // Check if argv contains a protocol URL (e.g., ssh://user@host)
+  // and use parseQuickConnect for proper parsing
+  if (argv && argv.length) {
+    const protocolUrl = argv.find(arg =>
+      /^(ssh|telnet|rdp|vnc|serial|spice|ftp|http|https|electerm):\/\//i.test(arg)
+    )
+    if (protocolUrl) {
+      const parsed = parseQuickConnect(protocolUrl)
+      if (parsed) {
+        return store.ipcOpenTab(parsed)
+      }
+    }
+  }
+
   const conf = getHost(argv, options)
   const update = {
     passphrase: options.passphrase,

package/client/store/mcp-handler.js

@@ -6,6 +6,7 @@
 import uid from '../common/uid'
 import { settingMap } from '../common/constants'
 import { refs, refsTabs } from '../components/common/ref'
+import { runCmd } from '../components/terminal/terminal-apis'
 import deepCopy from 'json-deep-copy'
 import {
   getLocalFileInfo,
@@ -118,6 +119,26 @@ export default Store => {
         case 'wait_for_terminal_idle':
           result = await store.mcpWaitForTerminalIdle(args)
           break
+        case 'get_terminal_status':
+          result = store.mcpGetTerminalStatus(args)
+          break
+        case 'cancel_terminal_command':
+          result = store.mcpCancelTerminalCommand(args)
+          break
+
+        // Background task operations
+        case 'run_background_command':
+          result = store.mcpRunBackgroundCommand(args)
+          break
+        case 'get_background_task_status':
+          result = await store.mcpGetBackgroundTaskStatus(args)
+          break
+        case 'get_background_task_log':
+          result = await store.mcpGetBackgroundTaskLog(args)
+          break
+        case 'cancel_background_task':
+          result = await store.mcpCancelBackgroundTask(args)
+          break
 
         // SFTP operations
         case 'sftp_list':
@@ -652,6 +673,216 @@ export default Store => {
     }
   }
 
+  // ==================== Terminal Status & Cancel ====================
+
+  Store.prototype.mcpGetTerminalStatus = function (args) {
+    const { store } = window
+    const tabId = args.tabId || store.activeTabId
+    if (!tabId) {
+      throw new Error('No active terminal')
+    }
+
+    const tabRef = refsTabs.get('tab-' + tabId)
+    const onData = tabRef?.state.terminalOnData || ''
+    const term = refs.get('term-' + tabId)
+
+    let output = ''
+    let lineCount = 0
+    if (term && term.term) {
+      const buffer = term.term.buffer.active
+      if (buffer) {
+        const lines = []
+        const cursorY = buffer.cursorY || 0
+        const baseY = buffer.baseY || 0
+        const totalLines = buffer.length || 0
+        const end = baseY + cursorY + 1
+        const start = Math.max(0, end - 20)
+        for (let i = start; i < Math.min(totalLines, end); i++) {
+          const line = buffer.getLine(i)
+          if (line) {
+            lines.push(line.translateToString(true))
+          }
+        }
+        output = lines.join('\n')
+        lineCount = lines.length
+      }
+    }
+
+    return {
+      tabId,
+      isRunning: onData === 'feed',
+      hasPasswordPrompt: onData === 'password',
+      isIdle: !onData,
+      output,
+      lineCount
+    }
+  }
+
+  Store.prototype.mcpCancelTerminalCommand = function (args) {
+    const { store } = window
+    const tabId = args.tabId || store.activeTabId
+    if (!tabId) {
+      throw new Error('No active terminal')
+    }
+
+    const term = refs.get('term-' + tabId)
+    if (!term || !term.attachAddon) {
+      throw new Error('Terminal not found')
+    }
+
+    term.attachAddon._sendData('\x03')
+    return {
+      success: true,
+      message: 'Sent Ctrl+C to terminal',
+      tabId
+    }
+  }
+
+  // ==================== Background Task Management ====================
+
+  const backgroundTasks = new Map()
+  let bgTaskCounter = 0
+
+  async function runMonitorCmd (tabId, cmd) {
+    try {
+      const result = await runCmd(tabId, cmd)
+      return result
+    } catch (e) {
+      // Fallback: send via terminal and wait for idle
+      const { store } = window
+      store.mcpSendTerminalCommand({ command: cmd, tabId })
+      const idle = await store.mcpWaitForTerminalIdle({
+        tabId, timeout: 10000, lines: 10, minWait: 500
+      })
+      return idle.output || ''
+    }
+  }
+
+  Store.prototype.mcpRunBackgroundCommand = function (args) {
+    const { store } = window
+    const tabId = args.tabId || store.activeTabId
+    if (!tabId) {
+      throw new Error('No active terminal')
+    }
+    if (!args.command) {
+      throw new Error('No command provided')
+    }
+
+    const taskId = `bg-${Date.now()}-${++bgTaskCounter}`
+    const logFile = `/tmp/electerm-${taskId}.log`
+    const pidFile = `/tmp/electerm-${taskId}.pid`
+    const exitFile = `/tmp/electerm-${taskId}.exit`
+
+    // Encode command as base64 to avoid all quote-escaping issues.
+    // The subshell runs the user's command, captures its exit code, then cleans up the PID file.
+    const b64 = btoa(args.command)
+    const inner = `eval "$(echo ${b64} | base64 --decode)" > ${logFile} 2>&1; e=$?; echo $e > ${exitFile}; rm -f ${pidFile}`
+    const wrapped = `nohup bash -c '${inner}' & echo $! > ${pidFile}; disown`
+
+    store.mcpSendTerminalCommand({ command: wrapped, tabId, inputOnly: false })
+
+    const task = {
+      id: taskId,
+      command: args.command,
+      tabId,
+      startTime: Date.now(),
+      logFile,
+      pidFile,
+      exitFile,
+      status: 'started'
+    }
+    backgroundTasks.set(taskId, task)
+
+    return {
+      taskId,
+      tabId,
+      logFile,
+      pidFile,
+      exitFile,
+      message: 'Command started in background. Use get_background_task_status to check.'
+    }
+  }
+
+  Store.prototype.mcpGetBackgroundTaskStatus = async function (args) {
+    const task = backgroundTasks.get(args.taskId)
+    if (!task) {
+      throw new Error(`Task ${args.taskId} not found`)
+    }
+
+    const pidOutput = await runMonitorCmd(task.tabId,
+      `cat ${task.pidFile} 2>/dev/null`)
+    const pid = pidOutput.trim()
+
+    if (!pid) {
+      return { ...task, status: 'unknown', message: 'PID file not found' }
+    }
+
+    const aliveCheck = await runMonitorCmd(task.tabId,
+      `kill -0 ${pid} 2>/dev/null && echo alive || echo dead`)
+
+    if (aliveCheck.trim() === 'alive') {
+      task.status = 'running'
+      return { ...task, pid, status: 'running' }
+    }
+
+    // Process exited — read exit code
+    const exitOutput = await runMonitorCmd(task.tabId,
+      `cat ${task.exitFile} 2>/dev/null`)
+    const exitCode = exitOutput.trim()
+
+    task.status = 'completed'
+    task.exitCode = exitCode !== '' ? parseInt(exitCode, 10) : null
+    task.endTime = Date.now()
+    return { ...task, pid, status: 'completed', exitCode: task.exitCode }
+  }
+
+  Store.prototype.mcpGetBackgroundTaskLog = async function (args) {
+    const task = backgroundTasks.get(args.taskId)
+    if (!task) {
+      throw new Error(`Task ${args.taskId} not found`)
+    }
+
+    const lines = args.lines || 100
+    const output = await runMonitorCmd(task.tabId,
+      `tail -n ${lines} ${task.logFile} 2>/dev/null || echo '(no output yet)'`)
+
+    return {
+      taskId: task.id,
+      output: output.trim(),
+      lines
+    }
+  }
+
+  Store.prototype.mcpCancelBackgroundTask = async function (args) {
+    const task = backgroundTasks.get(args.taskId)
+    if (!task) {
+      throw new Error(`Task ${args.taskId} not found`)
+    }
+
+    const pidOutput = await runMonitorCmd(task.tabId,
+      `cat ${task.pidFile} 2>/dev/null`)
+    const pid = pidOutput.trim()
+
+    if (pid) {
+      await runMonitorCmd(task.tabId,
+        `kill ${pid} 2>/dev/null; echo $? > ${task.exitFile}`)
+      task.status = 'cancelled'
+      task.endTime = Date.now()
+      return {
+        taskId: task.id,
+        pid,
+        status: 'cancelled',
+        message: 'Process killed'
+      }
+    }
+
+    return {
+      taskId: task.id,
+      status: 'unknown',
+      message: 'PID not found, task may have already finished'
+    }
+  }
+
   // ==================== Settings APIs ====================
 
   Store.prototype.mcpGetSettings = function () {

package/package.json

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