@electerm/electerm-react 5.5.56 → 5.5.76

package/client/store/mcp-handler.js

@@ -17,23 +17,16 @@ import {
   validateBookmarkData
 } from '../components/bookmark-form/fix-bookmark-default'
 import newTerm from '../common/new-terminal'
+import dangerousSessionFields from '../common/dangerous-session-fields'
 
 // Dangerous props that must not be accepted from MCP/AI tool calls.
-// Mirrors the blocklist in src/client/store/tab.js (dangerousTabProps).
-// These allow arbitrary command execution if set (e.g. execLinux/execLinuxArgs
-// override the shell binary, setEnv injects environment variables, runScripts
-// executes scripts, interactiveValues injects interactive prompts).
-const dangerousTabProps = [
-  'execLinux',
-  'execMac',
-  'execWindows',
-  'execWindowsArgs',
-  'execMacArgs',
-  'execLinuxArgs',
-  'setEnv',
-  'runScripts',
-  'interactiveValues'
-]
+// Shared with src/client/store/tab.js and the quick connect parser so the
+// copies cannot drift apart. These allow arbitrary command execution if set
+// (execLinux/execLinuxArgs override the shell binary, setEnv injects
+// environment variables, runScripts executes scripts, interactiveValues
+// injects interactive prompts, triggers auto-answer terminal output,
+// proxyCommand is spawned before any SSH authentication).
+const dangerousTabProps = dangerousSessionFields
 
 // Tab/session UI state keys that must never be set by MCP/AI callers.
 // A crafted `batch` (missing, string, or out-of-range) used to crash the

package/client/store/sync.js

@@ -742,29 +742,57 @@ export default (Store) => {
       }
       fixed[n] = arr
     }
-    // clear all targets first - importAll replaces data sets, not appends.
-    // watchers are stopped inside runImportTask, so this is silent until restart
-    action(() => {
-      for (const n of names) {
-        store.setItems(n, [])
-      }
-    })()
+    // Import replaces data sets, so the store has to end up holding exactly
+    // `fixed`. Keep a copy of what it holds now: if the import is cancelled or
+    // throws, this goes back, so the store and the watcher snapshots agree
+    // again and the watcher restart cannot be mistaken for a mass deletion.
+    const backup = new Map(
+      names.map(n => [n, copy(store.getItems(n))])
+    )
     await runImportTask({
       title: e('import'),
       batch: 200,
       stopWatchers: names,
-      // one chunked step per data set (bookmarks, groups, themes, ...),
-      // so the progress bar advances per batch instead of per data set
-      steps: names.map((n) => {
-        const arr = fixed[n]
-        return {
-          label: n,
-          items: arr,
-          process: (chunk) => {
-            store[n].push(...chunk)
+      // Clearing happens *inside* the task, i.e. while the watchers are
+      // stopped, rather than before it. Doing it earlier meant the empty store
+      // was already in place while the snapshots still described the full
+      // table, so any path that restarted a watcher without the import having
+      // finished (cancel, throw) deleted every record on disk.
+      steps: [
+        {
+          label: e('import'),
+          weight: 1,
+          run: () => {
+            action(() => {
+              for (const n of names) {
+                store.setItems(n, [])
+              }
+            })()
           }
-        }
-      })
+        },
+        // one chunked step per data set (bookmarks, groups, themes, ...),
+        // so the progress bar advances per batch instead of per data set
+        ...names.map((n) => {
+          const arr = fixed[n]
+          return {
+            label: n,
+            items: arr,
+            process: (chunk) => {
+              store[n].push(...chunk)
+            }
+          }
+        })
+      ],
+      // The import did not complete: put the store back the way it was so the
+      // watcher restart below is a no-op instead of deleting the untouched
+      // records. (import-task.js also reseeds each watcher before restarting.)
+      onAbort: () => {
+        action(() => {
+          for (const [n, arr] of backup) {
+            store.setItems(n, copy(arr))
+          }
+        })()
+      }
     })
     store.updateConfig(stripServerManagedKeys(objs.config))
     if (objs.config?.theme) {
@@ -819,6 +847,7 @@ export default (Store) => {
     const configSyncKeys = [
       'keepaliveInterval',
       'rightClickSelectsWord',
+      'mouseEventsRequireAlt',
       'pasteWhenContextMenu',
       'ctrlOrMetaOpenTerminalLink',
       'hotkey',

package/client/store/tab.js

@@ -18,6 +18,8 @@ import uid from '../common/uid'
 import newTerm, { updateCount } from '../common/new-terminal.js'
 import { action } from 'manate'
 import { shouldCaptureTerminalReloadState } from '../components/terminal/ssh-reload-state.js'
+import dangerousSessionFields from '../common/dangerous-session-fields'
+import { distributeTabsEvenly } from '../common/distribute-tabs'
 
 function captureSshSessionState (tab, config) {
   return shouldCaptureTerminalReloadState(tab, config)
@@ -415,23 +417,9 @@ 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',
-    'triggers'
-  ]
-
   Store.prototype.ipcOpenTab = function (parsed) {
     const safeTab = Object.fromEntries(
-      Object.entries(parsed).filter(([key]) => !dangerousTabProps.includes(key))
+      Object.entries(parsed).filter(([key]) => !dangerousSessionFields.includes(key))
     )
     return window.store.addTab(safeTab)
   }
@@ -504,12 +492,45 @@ export default Store => {
     }
     ntb.batch = (currentLayoutBatch + 1) % maxBatch
     if (layout === 'c1') {
-      store.setLayout('c2')
+      store.setLayout('c2', false)
     }
     store.addTab(ntb)
   }
 
-  Store.prototype.setLayout = function (layout) {
+  // Spread tabs over the panes of a layout with more panes.
+  // Only used when leaving the single layout: once more than one pane is on
+  // screen the arrangement is the user's, and is left alone.
+  Store.prototype.distributeTabs = function (newCount) {
+    const { store } = window
+    const { tabs } = store
+    if (tabs.length < 2) {
+      return
+    }
+    // contiguous chunks keep the tab order: [A B C D E] -> [A B] [C D] [E]
+    const batches = distributeTabsEvenly(tabs.length, newCount)
+    tabs.forEach((t, i) => {
+      t.batch = batches[i]
+    })
+  }
+
+  // make sure every pane has a valid active tab
+  Store.prototype.fixActiveTabIds = function (count) {
+    const { store } = window
+    for (let b = 0; b < count; b++) {
+      const inBatch = store.tabs.filter(t => t.batch === b)
+      const key = `activeTabId${b}`
+      if (!inBatch.some(t => t.id === store[key])) {
+        store[key] = inBatch.length ? inBatch[0].id : ''
+      }
+    }
+    const active = store.tabs.find(t => t.id === store.activeTabId)
+    if (active) {
+      store[`activeTabId${active.batch}`] = active.id
+      store.currentLayoutBatch = active.batch
+    }
+  }
+
+  Store.prototype.setLayout = function (layout, redistribute = true) {
     const { store } = window
     const prevLayout = store.layout
     const { activeTabId } = store
@@ -546,6 +567,15 @@ export default Store => {
       if (store.currentLayoutBatch >= newBatchCount) {
         store.currentLayoutBatch = newBatchCount - 1
       }
+    } else if (
+      redistribute &&
+      store.config.autoDistributeTabsWhenLayoutChange &&
+      prevBatchCount === 1 &&
+      newBatchCount > 1
+    ) {
+      // leaving the single layout: hand the tabs out evenly
+      store.distributeTabs(newBatchCount)
+      store.fixActiveTabIds(newBatchCount)
     }
     store.focus()
   }

package/client/store/watch.js

@@ -82,6 +82,14 @@ export default store => {
       }
       return store[name]
     }, schedule)
+    // Make the current store contents the watcher's baseline, so a later
+    // start() diffs against the store rather than a snapshot that no longer
+    // describes it. Needed after a rolled-back import: the store has just been
+    // restored to its pre-import state, and diffing that against the snapshot
+    // taken before the import would be read as "every record was removed".
+    window[`watch${name}`].reseed = () => {
+      refsStatic.add('oldState-' + name, deepCopy(store.getItems(name)) || [])
+    }
     window[`watch${name}`].start()
   }
 

package/package.json

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

package/client/components/terminal/reconnect-overlay.jsx

@@ -1,14 +0,0 @@
-import { memo } from 'react'
-
-const e = window.translate
-
-export default memo(function ReconnectOverlay ({ countdown }) {
-  if (countdown === null || countdown === undefined) {
-    return null
-  }
-  return (
-    <div className='terminal-reconnect-overlay'>
-      {e('autoReconnectTerminal')}: {countdown}s
-    </div>
-  )
-})