@electerm/electerm-react 5.5.35 → 5.5.56

package/client/common/bookmark-schemas.js

@@ -62,6 +62,7 @@ export const sshBookmarkSchema = {
   enableSftp: z.boolean().optional().describe('Enable sftp, default is true'),
   useSshAgent: z.boolean().optional().describe('Use SSH agent, default is true'),
   sshAgent: z.string().optional().describe('SSH agent path'),
+  agentForward: z.boolean().optional().describe('Enable SSH agent forwarding (like ssh -A), requires SSH agent, default is false'),
   serverHostKey: z.array(z.string()).optional().describe('Server host key algorithms'),
   cipher: z.array(z.string()).optional().describe('Cipher list'),
   compress: z.array(z.string()).optional().describe('Compression algorithms'),

package/client/common/constants.js

@@ -302,6 +302,7 @@ export const regexHelpLink = 'https://github.com/electerm/electerm/wiki/Terminal
 export const connectionHoppingWikiLink = 'https://github.com/electerm/electerm/wiki/Connection-Hopping-Behavior-Change-in-electerm-since-v1.50.65'
 export const aiConfigWikiLink = 'https://github.com/electerm/electerm/wiki/AI-model-config-guide'
 export const aiChatModeLsKey = 'ai-chat-mode'
+export const aiAutoCompressLsKey = 'ai-auto-compress'
 export const lastAiChatSessionIdKey = 'last-ai-chat-session-id'
 export const aiTermOfUseConfirmedLsKey = 'ai-term-of-use-confirmed'
 export const syncTermOfUseConfirmedLsKey = 'sync-term-of-use-confirmed'

package/client/common/parse-quick-connect.js

@@ -53,6 +53,7 @@ const TYPE_DEFAULT_VALUES = {
     enableSsh: true,
     enableSftp: true,
     useSshAgent: true,
+    agentForward: false,
     authType: 'password',
     term: 'xterm-256color',
     encode: 'utf-8',

package/client/common/parse-widget-log.js

@@ -0,0 +1,57 @@
+/**
+ * Parse a widget log file into the two streams the widget panel shows.
+ *
+ * The writer is src/app/widgets/instance-log.js; the format is one entry per
+ * line, pipe separated:
+ *   <iso time>|log|<level>|<message>
+ *   <iso time>|conn|<ok|fail|info>|<type>|<from>|<message>
+ * A message may contain pipes, so everything after the last known separator is
+ * taken as the message.
+ */
+
+const CONN_STATE = {
+  ok: true,
+  fail: false,
+  info: null
+}
+
+export function parseWidgetLog (text) {
+  const logs = []
+  const events = []
+  for (const line of String(text || '').split('\n')) {
+    if (!line) {
+      continue
+    }
+    const parts = line.split('|')
+    if (parts.length < 4) {
+      continue
+    }
+    const ts = Date.parse(parts[0])
+    if (!ts) {
+      continue
+    }
+    if (parts[1] === 'conn') {
+      if (parts.length < 6) {
+        continue
+      }
+      events.push({
+        ts,
+        ok: Object.prototype.hasOwnProperty.call(CONN_STATE, parts[2])
+          ? CONN_STATE[parts[2]]
+          : null,
+        type: parts[3],
+        from: parts[4] === '-' ? '' : parts[4],
+        msg: parts.slice(5).join('|')
+      })
+    } else {
+      logs.push({
+        ts,
+        level: parts[2],
+        msg: parts.slice(3).join('|')
+      })
+    }
+  }
+  return { logs, events }
+}
+
+export default parseWidgetLog

package/client/components/ai/agent-tool-call-card.jsx

@@ -1,4 +1,4 @@
-import { useState, useEffect } from 'react'
+import { useState, useEffect, memo } from 'react'
 import { Tag } from 'antd'
 import {
   CaretDownOutlined,
@@ -34,7 +34,11 @@ function formatResult (result) {
   }
 }
 
-export default function AgentToolCallCard ({ toolCall, autoCollapse }) {
+// memo()'d on the entry object: `formatResult` JSON.parses the whole tool
+// result on every render, and an agent turn can hold dozens of these. The
+// agent loop swaps in a new entry object when a call finishes
+// (runAgentLoop), so an unchanged card keeps its identity and is skipped.
+export default memo(function AgentToolCallCard ({ toolCall, autoCollapse }) {
   const [expanded, setExpanded] = useState(toolCall.status === 'running')
   const { name, args, status, result } = toolCall
   const Icon = toolIcons[name] || CodeOutlined
@@ -110,4 +114,4 @@ export default function AgentToolCallCard ({ toolCall, autoCollapse }) {
       )}
     </div>
   )
-}
+})

package/client/components/ai/agent.js

@@ -1,9 +1,31 @@
 import { agentTools, executeToolCall } from './agent-tools'
 import { appendMandatoryGuardrails } from './ai-guardrails'
-import { buildAgentMessages, summarizeContext } from './ai-context'
+import { buildAgentMessages, summarizeContext, CONTEXT_DANGER_PERCENT } from './ai-context'
+import {
+  shouldAutoCompress,
+  canCompact,
+  applySummary
+} from './ai-auto-compress'
+import {
+  autoCompressEnabled,
+  summarizeMessages,
+  autoCompressSession
+} from './ai-compress'
+import uid from '../../common/uid'
 
 const MAX_ITERATIONS = 150
 
+// A summary request that failed (provider hiccup, rate limit) must not be
+// retried on every following iteration -- that would turn a full window into a
+// call per tool result. Only try again once the estimate has grown by this
+// share of the window.
+const AUTO_COMPRESS_RETRY_GROWTH_PERCENT = 5
+
+// Which loop currently owns `store.agentRunning`. A stopped run keeps
+// unwinding for a moment (its last request has to settle), and it must not
+// clear the flag of a run the user started in the meantime.
+let activeRunId = null
+
 function buildAgentSystemPrompt (config) {
   const lang = config.languageAI || window.store.getLangName()
   const baseRole = config.roleAI || 'You are a helpful assistant.'
@@ -27,14 +49,10 @@ Reply in ${lang} language.`)
 }
 
 function updateChatEntry (chatEntry, updates) {
-  const index = window.store.aiChatHistory.findIndex(i => i.id === chatEntry.id)
-  if (index !== -1) {
-    Object.assign(window.store.aiChatHistory[index], updates)
-    window.store.aiChatHistory = [...window.store.aiChatHistory]
-  }
+  window.store.updateAiHistoryEntry(chatEntry.id, updates)
 }
 
-async function callBackendAIchatWithTools (messages, config) {
+async function callBackendAIchatWithTools (messages, config, requestId) {
   return window.pre.runGlobalAsync(
     'AIchatWithTools',
     messages,
@@ -44,7 +62,11 @@ async function callBackendAIchatWithTools (messages, config) {
     config.apiKeyAI,
     config.proxyAI,
     agentTools,
-    config.authHeaderNameAI
+    config.authHeaderNameAI,
+    // `format` stays undefined (the main process detects it); `requestId` is
+    // the last argument so that exact request can be cancelled on stop.
+    undefined,
+    requestId
   )
 }
 
@@ -67,7 +89,16 @@ function publishContext (messages, config, usage) {
 }
 
 export async function runAgentLoop (chatEntry, config, abortRef, setIsStreaming, conversationMessages = null) {
+  const runId = uid()
+  activeRunId = runId
   window.store.agentRunning = true
+  const isAborted = () => !!(abortRef && abortRef.current)
+  // Auto compression bookkeeping, read by the finally block as well: how many
+  // times this run compacted itself, whether it failed on the way, and the
+  // size at the last summary attempt (AUTO_COMPRESS_RETRY_GROWTH_PERCENT)
+  let autoCompressCount = 0
+  let autoCompressAttemptTokens = 0
+  let runErrored = false
   try {
     const messages = buildAgentMessages({
       systemPrompt: buildAgentSystemPrompt(config),
@@ -78,6 +109,13 @@ export async function runAgentLoop (chatEntry, config, abortRef, setIsStreaming,
     let accumulatedContent = ''
     let lastUsage = null
 
+    const markStopped = () => {
+      setIsStreaming(false)
+      updateChatEntry(chatEntry, {
+        response: accumulatedContent + '\n\n*(Agent stopped by user)*'
+      })
+    }
+
     setIsStreaming(true)
     updateChatEntry(chatEntry, {
       toolCalls: [],
@@ -85,21 +123,79 @@ export async function runAgentLoop (chatEntry, config, abortRef, setIsStreaming,
     })
 
     for (let iteration = 0; iteration < MAX_ITERATIONS; iteration++) {
-      if (abortRef && abortRef.current) {
-        setIsStreaming(false)
-        updateChatEntry(chatEntry, {
-          response: accumulatedContent + '\n\n*(Agent stopped by user)*'
-        })
+      if (isAborted()) {
+        markStopped()
         return
       }
 
       publishContext(messages, config, lastUsage)
-      const result = await callBackendAIchatWithTools(messages, config)
+
+      // Auto compression, when the popover toggle is on: the request about to
+      // go out carries the whole conversation plus a tool result per step, and
+      // past ~90% of the window the provider rejects it outright. Replacing the
+      // conversation with a summary first keeps the run alive; the stored
+      // session is compacted at the end (autoCompressSession), because that is
+      // what the next turn starts from.
+      const info = window.store.aiContextInfo
+      // A failed summary is only worth retrying once the context has grown by
+      // this much -- but never more than the trigger itself, or a threshold
+      // below it would let the retry floor decide when to compress.
+      const growthPercent = Math.min(
+        AUTO_COMPRESS_RETRY_GROWTH_PERCENT,
+        CONTEXT_DANGER_PERCENT
+      )
+      const grewEnough = info &&
+        info.tokens - autoCompressAttemptTokens >=
+          (info.windowSize || 0) * growthPercent / 100
+      if (
+        autoCompressEnabled() &&
+        canCompact(messages) &&
+        shouldAutoCompress(info) &&
+        grewEnough
+      ) {
+        autoCompressAttemptTokens = info.tokens
+        // Shown before the request rather than after: summarizing a nearly full
+        // window takes a while, and this badge is the only sign of why the run
+        // is waiting. Taken back if the summary comes back unusable.
+        updateChatEntry(chatEntry, { autoCompressCount: autoCompressCount + 1 })
+        const summary = await summarizeMessages(messages, config)
+        if (isAborted()) {
+          markStopped()
+          return
+        }
+        if (summary) {
+          applySummary(messages, summary)
+          autoCompressCount++
+          lastUsage = null
+          publishContext(messages, config, null)
+        } else {
+          updateChatEntry(chatEntry, { autoCompressCount })
+        }
+      }
+
+      const requestId = uid()
+      if (abortRef) {
+        abortRef.requestId = requestId
+      }
+      const result = await callBackendAIchatWithTools(messages, config, requestId)
+      if (abortRef && abortRef.requestId === requestId) {
+        abortRef.requestId = null
+      }
+
+      // Re-check after the await, before anything from the answer is used:
+      // stopping cancels the request, and neither the partial answer nor the
+      // resulting error belongs in the transcript.
+      if (isAborted()) {
+        markStopped()
+        return
+      }
+
       if (result.usage) {
         lastUsage = result.usage
       }
 
       if (result.error) {
+        runErrored = true
         setIsStreaming(false)
         updateChatEntry(chatEntry, {
           response: accumulatedContent + `\n\n**Error:** ${result.error}`
@@ -109,6 +205,7 @@ export async function runAgentLoop (chatEntry, config, abortRef, setIsStreaming,
 
       const assistantMessage = result.message
       if (!assistantMessage) {
+        runErrored = true
         setIsStreaming(false)
         updateChatEntry(chatEntry, {
           response: accumulatedContent || 'No response from AI.'
@@ -135,11 +232,8 @@ export async function runAgentLoop (chatEntry, config, abortRef, setIsStreaming,
       }
 
       for (const toolCall of assistantMessage.tool_calls) {
-        if (abortRef && abortRef.current) {
-          setIsStreaming(false)
-          updateChatEntry(chatEntry, {
-            response: accumulatedContent + '\n\n*(Agent stopped by user)*'
-          })
+        if (isAborted()) {
+          markStopped()
           return
         }
 
@@ -150,28 +244,32 @@ export async function runAgentLoop (chatEntry, config, abortRef, setIsStreaming,
           args = {}
         }
 
-        const toolEntry = {
+        toolCallsLog.push({
           id: toolCall.id,
           name: toolCall.function.name,
           args,
           status: 'running',
           result: null
-        }
-        toolCallsLog.push(toolEntry)
+        })
         updateChatEntry(chatEntry, {
           toolCalls: [...toolCallsLog]
         })
 
-        let toolResult
+        let finished
         try {
-          toolResult = await executeToolCall(toolCall.function.name, args)
-          toolEntry.status = 'completed'
-          toolEntry.result = toolResult
+          const toolResult = await executeToolCall(toolCall.function.name, args)
+          finished = { status: 'completed', result: toolResult }
         } catch (err) {
-          toolEntry.status = 'error'
-          toolEntry.result = err.message
+          finished = { status: 'error', result: err.message }
         }
 
+        // Swap in a new entry object instead of mutating the running one: the
+        // tool call card is memo()'d on that object's identity, so an in-place
+        // mutation would leave the card showing "running" forever.
+        toolCallsLog[toolCallsLog.length - 1] = {
+          ...toolCallsLog[toolCallsLog.length - 1],
+          ...finished
+        }
         updateChatEntry(chatEntry, {
           toolCalls: [...toolCallsLog]
         })
@@ -179,7 +277,7 @@ export async function runAgentLoop (chatEntry, config, abortRef, setIsStreaming,
         messages.push({
           role: 'tool',
           tool_call_id: toolCall.id,
-          content: toolEntry.result
+          content: finished.result
         })
       }
     }
@@ -189,9 +287,54 @@ export async function runAgentLoop (chatEntry, config, abortRef, setIsStreaming,
       response: accumulatedContent + '\n\n*(Agent reached maximum iterations)*'
     })
   } finally {
-    window.store.agentRunning = false
-    // hand the panel back to the session based estimate: tool results are not
-    // carried into the next turn, so the agent figure stops being meaningful
-    window.store.aiContextInfo = null
+    if (abortRef) {
+      abortRef.requestId = null
+    }
+    // Only the run that still owns the flag may clear it -- a stopped run
+    // unwinds a moment later and must not unlock a newer one.
+    const ownsRun = activeRunId === runId
+    if (ownsRun) {
+      activeRunId = null
+      window.store.agentRunning = false
+      // hand the panel back to the session based estimate: tool results are not
+      // carried into the next turn, so the agent figure stops being meaningful
+      window.store.aiContextInfo = null
+    }
+    // A run that compacted its live conversation leaves the stored session
+    // untouched, so the next turn would start from the full history again and
+    // pay for another summary. Compact the session as well -- once, after the
+    // run, when the turns it summarizes are complete. Skipped for a stopped or
+    // failed run: those transcripts are not a conversation worth keeping.
+    if (ownsRun && autoCompressCount > 0 && !runErrored && !isAborted()) {
+      await autoCompressSession(chatEntry.chatSessionId, config)
+    }
+  }
+}
+
+// Stop the running agent loop, called by the panel's stop button.
+//
+// The loop itself only looks at `abortRef` between iterations, so on its own
+// that flag does nothing while a request is in flight -- and the panel keeps
+// the composer locked for as long as the provider takes to answer (which is
+// forever if it never does, these requests carry no timeout). So this also
+// cancels the in-flight request and releases the composer right away; the loop
+// then unwinds on its own and marks the entry as stopped.
+export async function stopAgentRun (abortRef) {
+  if (abortRef) {
+    abortRef.current = true
+  }
+  const requestId = abortRef && abortRef.requestId
+  if (abortRef) {
+    abortRef.requestId = null
+  }
+  activeRunId = null
+  window.store.agentRunning = false
+  window.store.aiContextInfo = null
+  if (requestId) {
+    try {
+      await window.pre.runGlobalAsync('abortAIRequest', requestId)
+    } catch (error) {
+      console.error('Error aborting agent request:', error)
+    }
   }
 }

package/client/components/ai/ai-auto-compress.js

@@ -0,0 +1,119 @@
+// Automatic context compression, shared by agent mode and ask mode.
+//
+// A request is not just the conversation: agent runs append the assistant's
+// tool calls and their results on every iteration, ask turns append the answer
+// of every turn. Either way the request that leaves the machine grows past what
+// the session transcript suggests, and once it approaches the model's window
+// the provider starts rejecting it outright, which kills the run mid-way. The
+// fix is the same one the manual Compress button performs -- replace the
+// history with a summary -- except it has to happen before the request that
+// would overflow.
+//
+// Pure module (no window / store access) so the decision and the rewrite can
+// be unit tested, and so the manual and the automatic path share one summary
+// prompt and one message shape. The request that asks for a summary lives in
+// ai-compress.js.
+
+import { CONTEXT_DANGER_PERCENT } from './ai-context.js'
+
+// Sent as the closing user turn when asking for a summary. Shared with the
+// manual path (store.compressChatSession) so both produce the same thing.
+export const COMPRESS_SUMMARY_PROMPT = 'Please summarize the above conversation concisely. Include key information, decisions, context, and any important details that would be needed to continue this conversation effectively.'
+
+// `info` is the object summarizeContext returns. Percent is null/absent when
+// the window size is unknown, which must not read as "0, no compression
+// needed" -- there is simply nothing to decide on.
+//
+// The threshold is the danger level from ai-context.js, read here rather than
+// copied into a constant of this module: the same value is what turns the
+// context indicator red, and a live read cannot be left behind in a stale copy
+// of this file when that value is edited (which is how "I set it to 5 and it
+// still did not compress" happens).
+export function shouldAutoCompress (info, percent = CONTEXT_DANGER_PERCENT) {
+  if (!info) {
+    return false
+  }
+  const p = info.percent
+  if (p === null || p === undefined || !isFinite(p)) {
+    return false
+  }
+  return p >= percent
+}
+
+// There has to be something a summary can replace. A fresh request is just the
+// system prompt plus the prompt being sent; compacting that would only re-word
+// the question, so a model whose tool schemas alone fill the window is left
+// alone rather than sent a summary request on every turn.
+export function canCompact (messages) {
+  return Array.isArray(messages) && messages.length > 2
+}
+
+// An ask-mode request ends with the prompt being answered, because
+// buildSessionMessages appends each turn's prompt after the earlier ones.
+// Compaction must keep that last message out of the summary: it is the live
+// question, and folding it into "here is a summary of our previous
+// conversation" would ask the model to answer a question it only sees quoted
+// back at it.
+export function splitPendingTurn (messages) {
+  if (!Array.isArray(messages)) {
+    return { context: [], pending: null }
+  }
+  const last = messages[messages.length - 1]
+  if (last && last.role === 'user') {
+    return { context: messages.slice(0, -1), pending: last }
+  }
+  return { context: messages, pending: null }
+}
+
+// How a summary re-enters the conversation. Deliberately the same pair
+// buildSessionMessages emits for a compressed session entry, so a live loop
+// that compacted itself and a session compressed between turns read
+// identically to the model.
+export function summaryMessages (summary) {
+  return [
+    {
+      role: 'user',
+      content: `Here is a summary of our previous conversation for context:\n\n${summary}`
+    },
+    {
+      role: 'assistant',
+      content: 'Understood. I will use this context as we continue.'
+    }
+  ]
+}
+
+// Compact `messages` in place: the system prompt stays (it carries the agent
+// instructions and guardrails), everything the summary covers is dropped.
+// In place because the agent loop holds this exact array for its next request.
+export function applySummary (messages, summary) {
+  if (!Array.isArray(messages) || !summary) {
+    return messages
+  }
+  const system = messages.find(m => m && m.role === 'system')
+  messages.length = 0
+  if (system) {
+    messages.push(system)
+  }
+  messages.push(...summaryMessages(summary))
+  return messages
+}
+
+// The ask-mode counterpart, returning a new list: the memoized session messages
+// this turn was built from must not be modified, and the live prompt has to be
+// re-attached after the summary.
+export function compactAskMessages (messages, summary) {
+  if (!Array.isArray(messages) || !summary) {
+    return messages
+  }
+  const { pending } = splitPendingTurn(messages)
+  const system = messages.find(m => m && m.role === 'system')
+  const next = []
+  if (system) {
+    next.push(system)
+  }
+  next.push(...summaryMessages(summary))
+  if (pending) {
+    next.push(pending)
+  }
+  return next
+}