@electerm/electerm-react 3.10.0 → 3.11.11

package/client/common/bookmark-schemas.js

@@ -0,0 +1,165 @@
+/**
+ * Bookmark schemas (ES module version for client)
+ * Mirrors src/app/common/bookmark-zod-schemas.js with additional types
+ */
+import { z } from './zod'
+
+// const runScriptSchema = z.object({
+//   delay: z.number().optional().describe('Delay in ms before executing this command'),
+//   script: z.string().describe('Command to execute')
+// })
+
+const quickCommandSchema = z.object({
+  name: z.string().describe('Quick command name'),
+  command: z.string().describe('Command')
+})
+
+const sshTunnelSchema = z.object({
+  sshTunnel: z.enum(['forwardRemoteToLocal', 'forwardLocalToRemote', 'dynamicForward']).describe('Tunnel type'),
+  sshTunnelLocalHost: z.string().optional().describe('Local host'),
+  sshTunnelLocalPort: z.number().optional().describe('Local port'),
+  sshTunnelRemoteHost: z.string().optional().describe('Remote host'),
+  sshTunnelRemotePort: z.number().optional().describe('Remote port'),
+  name: z.string().optional().describe('Tunnel name')
+})
+
+const connectionHoppingSchema = z.object({
+  host: z.string().describe('Host address'),
+  port: z.number().optional().describe('Port number'),
+  username: z.string().optional().describe('Username'),
+  password: z.string().optional().describe('Password'),
+  privateKey: z.string().optional().describe('Private key'),
+  passphrase: z.string().optional().describe('Passphrase'),
+  certificate: z.string().optional().describe('Certificate'),
+  authType: z.string().optional().describe('Auth type'),
+  profile: z.string().optional().describe('Profile id')
+})
+
+const commonNetworkBookmarkProps = {
+  title: z.string().describe('Bookmark title'),
+  host: z.string().describe('Host address'),
+  port: z.number().optional().describe('Port number'),
+  username: z.string().optional().describe('Username'),
+  password: z.string().optional().describe('Password'),
+  description: z.string().optional().describe('Bookmark description'),
+  startDirectoryRemote: z.string().optional().describe('Remote starting directory'),
+  startDirectoryLocal: z.string().optional().describe('Local starting directory'),
+  profile: z.string().optional().describe('Profile id'),
+  proxy: z.string().optional().describe('Proxy address (socks5://...)')
+}
+
+export const sshBookmarkSchema = {
+  ...commonNetworkBookmarkProps,
+  host: z.string().describe('SSH host address'),
+  port: z.number().optional().describe('SSH port (default 22)'),
+  username: z.string().optional().describe('SSH username'),
+  password: z.string().optional().describe('SSH password'),
+  authType: z.enum(['password', 'privateKey', 'profiles']).optional().describe('Authentication type'),
+  privateKey: z.string().optional().describe('Private key content or path (for privateKey auth)'),
+  passphrase: z.string().optional().describe('Passphrase for private key/certificate'),
+  certificate: z.string().optional().describe('Certificate content'),
+  enableSsh: z.boolean().optional().describe('Enable ssh, default is true'),
+  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'),
+  serverHostKey: z.array(z.string()).optional().describe('Server host key algorithms'),
+  cipher: z.array(z.string()).optional().describe('Cipher list'),
+  quickCommands: z.array(quickCommandSchema).optional().describe('Quick commands'),
+  x11: z.boolean().optional().describe('Enable x11 forwarding, default is false'),
+  term: z.string().optional().describe('Terminal type, default is xterm-256color'),
+  displayRaw: z.boolean().optional().describe('Display raw output, default is false'),
+  encode: z.string().optional().describe('Charset, default is utf8'),
+  envLang: z.string().optional().describe('ENV LANG, default is en_US.UTF-8'),
+  color: z.string().optional().describe('Tag color, like #000000'),
+  sshTunnels: z.array(sshTunnelSchema).optional().describe('SSH tunnel definitions'),
+  connectionHoppings: z.array(connectionHoppingSchema).optional().describe('Connection hopping definitions')
+}
+
+export const telnetBookmarkSchema = {
+  ...commonNetworkBookmarkProps,
+  host: z.string().describe('Telnet host address'),
+  port: z.number().optional().describe('Telnet port (default 23)'),
+  username: z.string().optional().describe('Telnet username'),
+  password: z.string().optional().describe('Telnet password'),
+  loginPrompt: z.string().optional().describe('Login prompt regex'),
+  passwordPrompt: z.string().optional().describe('Password prompt regex')
+}
+
+export const serialBookmarkSchema = {
+  title: z.string().describe('Bookmark title'),
+  path: z.string().describe('Serial device path, e.g., /dev/ttyUSB0 or COM1'),
+  baudRate: z.number().optional().describe('Baud rate (default 9600)'),
+  dataBits: z.number().optional().describe('Data bits (default 8)'),
+  stopBits: z.number().optional().describe('Stop bits (default 1)'),
+  parity: z.enum(['none', 'even', 'odd', 'mark', 'space']).optional().describe('Parity (default none)'),
+  rtscts: z.boolean().optional().describe('RTS/CTS flow control'),
+  xon: z.boolean().optional().describe('XON flow control'),
+  xoff: z.boolean().optional().describe('XOFF flow control'),
+  xany: z.boolean().optional().describe('XANY flow control'),
+  lineEnding: z.enum(['', '\r', '\n', '\r\n']).optional().describe('Line ending for Enter key: "" (none), "\\r" (CR), "\\n" (LF), "\\r\\n" (CR+LF)'),
+  description: z.string().optional().describe('Bookmark description')
+}
+
+export const vncBookmarkSchema = {
+  ...commonNetworkBookmarkProps,
+  host: z.string().describe('VNC host address'),
+  port: z.number().optional().describe('VNC port (default 5900)'),
+  viewOnly: z.boolean().optional().describe('View only mode, default is false'),
+  clipViewport: z.boolean().optional().describe('Clip viewport to window'),
+  scaleViewport: z.boolean().optional().describe('Scale viewport to window, default is true'),
+  qualityLevel: z.number().optional().describe('VNC quality level 0-9, lower is faster, default 3'),
+  compressionLevel: z.number().optional().describe('VNC compression level 0-9, lower is faster, default 1'),
+  shared: z.boolean().optional().describe('Shared session, default is true')
+}
+
+export const rdpBookmarkSchema = {
+  ...commonNetworkBookmarkProps,
+  host: z.string().describe('RDP host address'),
+  port: z.number().optional().describe('RDP port (default 3389)'),
+  domain: z.string().optional().describe('Login domain')
+}
+
+export const ftpBookmarkSchema = {
+  title: z.string().describe('Bookmark title'),
+  host: z.string().describe('FTP host address'),
+  port: z.number().optional().describe('FTP port (default 21)'),
+  user: z.string().optional().describe('FTP username'),
+  password: z.string().optional().describe('FTP password'),
+  secure: z.boolean().optional().describe('Use secure FTP (FTPS), default is false'),
+  encode: z.string().optional().describe('Charset for file names, default is utf-8'),
+  profile: z.string().optional().describe('Profile id'),
+  description: z.string().optional().describe('Bookmark description')
+}
+
+export const webBookmarkSchema = {
+  url: z.string().describe('Website URL'),
+  title: z.string().optional().describe('Bookmark title'),
+  description: z.string().optional().describe('Bookmark description'),
+  useragent: z.string().optional().describe('Custom user agent')
+}
+
+export const localBookmarkSchema = {
+  title: z.string().describe('Bookmark title'),
+  description: z.string().optional().describe('Bookmark description'),
+  startDirectoryLocal: z.string().optional().describe('Local starting directory')
+}
+
+export const spiceBookmarkSchema = {
+  ...commonNetworkBookmarkProps,
+  host: z.string().describe('Spice host address'),
+  port: z.number().optional().describe('Spice port (default 5900)'),
+  viewOnly: z.boolean().optional().describe('View only mode'),
+  scaleViewport: z.boolean().optional().describe('Scale viewport to window, default is true')
+}
+
+export const bookmarkSchemas = {
+  ssh: sshBookmarkSchema,
+  telnet: telnetBookmarkSchema,
+  serial: serialBookmarkSchema,
+  vnc: vncBookmarkSchema,
+  rdp: rdpBookmarkSchema,
+  ftp: ftpBookmarkSchema,
+  web: webBookmarkSchema,
+  local: localBookmarkSchema,
+  spice: spiceBookmarkSchema
+}

package/client/common/constants.js

@@ -180,6 +180,13 @@ export const commonParities = [
   'none', 'even', 'mark', 'odd', 'space'
 ]
 
+export const commonLineEndings = [
+  { value: '', label: 'none' },
+  { value: '\r', label: 'CR' },
+  { value: '\n', label: 'LF' },
+  { value: '\r\n', label: 'CR+LF' }
+]
+
 export const maxBatchInput = 30
 export const windowControlWidth = 94
 export const baseUpdateCheckUrls = [

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

@@ -115,8 +115,11 @@ function parseQuickConnect (str) {
   }
 
   try {
+    // Strip trailing slashes (supports pasted URLs like host/ or ssh://host/)
+    const input = trimmed.replace(/\/+$/, '')
+
     // Detect protocol
-    const protocolMatch = trimmed.match(/^(ssh|telnet|vnc|rdp|spice|serial|ftp|https?|electerm):\/\//i)
+    const protocolMatch = input.match(/^(ssh|telnet|vnc|rdp|spice|serial|ftp|https?|electerm):\/\//i)
 
     let protocol = ''
     let connectionString = ''
@@ -129,28 +132,28 @@ function parseQuickConnect (str) {
       if (protocol === 'http' || protocol === 'https') {
         protocol = 'web'
       }
-      connectionString = trimmed.slice(protocolMatch[0].length)
+      connectionString = input.slice(protocolMatch[0].length)
     } else {
       // Shortcut format - default to SSH
       // Match user@host or user@host:port or just host or host:port
       // Use last colon to determine port for host:port format
-      if (/^[\w.-]+@[\w.-]+/.test(trimmed)) {
+      if (/^[\w.-]+@[\w.-]+/.test(input)) {
         // user@host or user@host:port
         protocol = 'ssh'
-        connectionString = trimmed
-      } else if (/^[\w.-]+:.*:[\d]+$/.test(trimmed)) {
+        connectionString = input
+      } else if (/^[\w.-]+:.*:[\d]+$/.test(input)) {
         // host:port format with colons in hostname (e.g., localhost:23344, zxd:localhost:23344)
         // Check if the last colon is followed by digits (port number)
         protocol = 'ssh'
-        connectionString = trimmed
-      } else if (/^[\w.-]+:[\d]+$/.test(trimmed)) {
+        connectionString = input
+      } else if (/^[\w.-]+:[\d]+$/.test(input)) {
         // host:port (no username, simple format like host:22)
         protocol = 'ssh'
-        connectionString = trimmed
-      } else if (/^[\w.-]+$/.test(trimmed)) {
+        connectionString = input
+      } else if (/^[\w.-]+$/.test(input)) {
         // just host
         protocol = 'ssh'
-        connectionString = trimmed
+        connectionString = input
       } else {
         return null
       }

package/client/common/sanitize-filename.js

@@ -0,0 +1,66 @@
+/**
+ * Sanitize a filename for cross-platform file transfers.
+ *
+ * When transferring files between different OS (Linux <-> Windows <-> macOS),
+ * filenames may contain characters that are illegal on the destination OS.
+ * Windows is the most restrictive common platform, so we use its rules as
+ * the baseline for maximum compatibility.
+ *
+ * Rules applied:
+ * - Remove control characters (0x00-0x1F)
+ * - Replace reserved characters: < > : " / \ | ? * with _
+ * - Remove leading/trailing dots and spaces (Windows restriction)
+ * - Reject reserved Windows device names: CON, PRN, AUX, NUL, COM1-9, LPT1-9
+ * - Limit filename length to 255 bytes (common filesystem limit)
+ * - Fallback to 'unnamed' if result is empty
+ */
+
+// Characters illegal on Windows (and problematic on many systems)
+// eslint-disable-next-line no-control-regex
+const ILLEGAL_CHARS = /[<>:"/\\|?\x00-\x1f]/g
+
+// Leading/trailing dots and spaces are problematic on Windows
+const LEADING_TRAILING = /^[.\s]+|[.\s]+$/g
+
+// Reserved Windows device names (case-insensitive)
+const RESERVED_NAMES = /^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\.|$)/i
+
+const MAX_FILENAME_LENGTH = 255
+
+const REPLACEMENT_CHAR = '_'
+
+export default function sanitizeFilename (name) {
+  if (!name || typeof name !== 'string') {
+    return 'unnamed'
+  }
+
+  let safe = name
+    // Replace illegal characters
+    .replace(ILLEGAL_CHARS, REPLACEMENT_CHAR)
+    // Strip leading/trailing dots and spaces
+    .replace(LEADING_TRAILING, '')
+
+  // Handle reserved Windows device names by appending underscore
+  if (RESERVED_NAMES.test(safe)) {
+    safe = safe + REPLACEMENT_CHAR
+  }
+
+  // Truncate to max length
+  if (safe.length > MAX_FILENAME_LENGTH) {
+    const ext = safe.lastIndexOf('.')
+    if (ext > 0) {
+      // Preserve extension when truncating
+      const extension = safe.slice(ext)
+      safe = safe.slice(0, MAX_FILENAME_LENGTH - extension.length) + extension
+    } else {
+      safe = safe.slice(0, MAX_FILENAME_LENGTH)
+    }
+  }
+
+  // Fallback for empty result
+  if (!safe) {
+    return 'unnamed'
+  }
+
+  return safe
+}

package/client/common/ws.js

@@ -57,8 +57,15 @@ class Ws {
 
   addEventListener (type = 'message', cb = this.cb) {
     this.cb = cb
-    const id = this.eid || generate()
-    this.eid = id
+    const id = generate()
+    if (!this.eids) {
+      this.eids = new Set()
+    }
+    if (!this.cbToId) {
+      this.cbToId = new Map()
+    }
+    this.eids.add(id)
+    this.cbToId.set(cb, id)
     persists[id] = {
       resolve: cb
     }
@@ -71,9 +78,15 @@ class Ws {
   }
 
   removeEventListener (type, cb) {
-    delete persists[this.eid]
+    if (!this.cbToId || !this.cbToId.has(cb)) {
+      return
+    }
+    const id = this.cbToId.get(cb)
+    this.cbToId.delete(cb)
+    this.eids.delete(id)
+    delete persists[id]
     send({
-      id: this.eid,
+      id,
       wsId: this.id,
       type,
       action: 'removeEventListener'
@@ -85,8 +98,14 @@ class Ws {
   }
 
   clearOnces () {
-    if (this.eid) {
-      delete persists[this.eid]
+    if (this.eids) {
+      for (const eid of this.eids) {
+        delete persists[eid]
+      }
+      this.eids.clear()
+    }
+    if (this.cbToId) {
+      this.cbToId.clear()
     }
     const ids = [...this.onceIds]
     ids.forEach(k => {

package/client/common/zod.js

@@ -0,0 +1,180 @@
+/**
+ * Lightweight zod replacement (ES module version for client)
+ * Covers only the API surface used in the project:
+ * z.string(), z.number(), z.boolean(), z.any(),
+ * z.enum(), z.object(), z.array(), z.record(),
+ * .optional(), .describe(), z.toJSONSchema()
+ */
+
+class ZodType {
+  constructor (typeName, meta = {}) {
+    this._typeName = typeName
+    this._optional = false
+    this._description = undefined
+    this._meta = meta
+    this['~standard'] = { type: typeName }
+  }
+
+  optional () {
+    const clone = this._clone()
+    clone._optional = true
+    return clone
+  }
+
+  describe (desc) {
+    const clone = this._clone()
+    clone._description = desc
+    return clone
+  }
+
+  _clone () {
+    const clone = Object.create(Object.getPrototypeOf(this))
+    Object.assign(clone, this)
+    clone['~standard'] = { ...this['~standard'] }
+    return clone
+  }
+
+  _toJsonSchema () {
+    throw new Error('_toJsonSchema not implemented for ' + this._typeName)
+  }
+}
+
+class ZodString extends ZodType {
+  constructor () {
+    super('string')
+  }
+
+  _toJsonSchema () {
+    return { type: 'string' }
+  }
+}
+
+class ZodNumber extends ZodType {
+  constructor () {
+    super('number')
+  }
+
+  _toJsonSchema () {
+    return { type: 'number' }
+  }
+}
+
+class ZodBoolean extends ZodType {
+  constructor () {
+    super('boolean')
+  }
+
+  _toJsonSchema () {
+    return { type: 'boolean' }
+  }
+}
+
+class ZodEnum extends ZodType {
+  constructor (values) {
+    super('enum', { values })
+  }
+
+  _toJsonSchema () {
+    return { type: 'string', enum: this._meta.values }
+  }
+}
+
+class ZodArray extends ZodType {
+  constructor (itemSchema) {
+    super('array', { itemSchema })
+  }
+
+  _toJsonSchema () {
+    const items = schemaToJsonSchema(this._meta.itemSchema)
+    return { type: 'array', items }
+  }
+}
+
+class ZodObject extends ZodType {
+  constructor (shape) {
+    super('object', { shape })
+  }
+
+  _toJsonSchema () {
+    const properties = {}
+    const required = []
+    const shape = this._meta.shape || {}
+    for (const [key, schema] of Object.entries(shape)) {
+      properties[key] = schemaToJsonSchema(schema)
+      if (schema._description) {
+        properties[key].description = schema._description
+      }
+      if (!schema._optional) {
+        required.push(key)
+      }
+    }
+    const result = { type: 'object', properties }
+    if (required.length > 0) {
+      result.required = required
+    }
+    return result
+  }
+}
+
+function schemaToJsonSchema (schema) {
+  if (!schema) {
+    return {}
+  }
+  if (schema instanceof ZodType) {
+    const base = schema._toJsonSchema()
+    if (schema._description) {
+      base.description = schema._description
+    }
+    return base
+  }
+  if (typeof schema === 'object' && !Array.isArray(schema)) {
+    return objectShapeToJsonSchema(schema)
+  }
+  return {}
+}
+
+function objectShapeToJsonSchema (shape) {
+  const properties = {}
+  const required = []
+  for (const [key, value] of Object.entries(shape)) {
+    if (value instanceof ZodType) {
+      properties[key] = schemaToJsonSchema(value)
+      if (value._description) {
+        properties[key].description = value._description
+      }
+      if (!value._optional) {
+        required.push(key)
+      }
+    }
+  }
+  const result = { type: 'object', properties }
+  if (required.length > 0) {
+    result.required = required
+  }
+  return result
+}
+
+export const z = {
+  string: () => new ZodString(),
+  number: () => new ZodNumber(),
+  boolean: () => new ZodBoolean(),
+  enum: (values) => new ZodEnum(values),
+  object: (shape) => new ZodObject(shape || {}),
+  array: (itemSchema) => new ZodArray(itemSchema),
+  toJSONSchema: (schema) => {
+    if (schema instanceof ZodType) {
+      return schema._toJsonSchema()
+    }
+    if (typeof schema === 'object' && schema !== null) {
+      const hasZodValues = Object.values(schema).some(
+        v => v instanceof ZodType
+      )
+      if (hasZodValues) {
+        return objectShapeToJsonSchema(schema)
+      }
+    }
+    return { type: 'object', properties: {} }
+  }
+}
+
+export { ZodType, schemaToJsonSchema }

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

@@ -0,0 +1,90 @@
+import { useState } from 'react'
+import { Tag } from 'antd'
+import {
+  CaretDownOutlined,
+  CaretRightOutlined,
+  LoadingOutlined,
+  CheckCircleOutlined,
+  CloseCircleOutlined,
+  CodeOutlined,
+  DatabaseOutlined
+} from '@ant-design/icons'
+
+const toolIcons = {
+  send_terminal_command: CodeOutlined,
+  get_terminal_output: CodeOutlined,
+  open_local_terminal: CodeOutlined,
+  list_tabs: CodeOutlined,
+  get_active_tab: CodeOutlined,
+  switch_tab: CodeOutlined,
+  list_bookmarks: DatabaseOutlined,
+  open_bookmark: DatabaseOutlined,
+  add_bookmark: DatabaseOutlined
+}
+
+function formatResult (result) {
+  if (!result) return ''
+  try {
+    const parsed = JSON.parse(result)
+    if (parsed.output) return parsed.output
+    return JSON.stringify(parsed, null, 2)
+  } catch {
+    return result
+  }
+}
+
+export default function AgentToolCallCard ({ toolCall }) {
+  const [expanded, setExpanded] = useState(toolCall.status === 'running')
+  const { name, args, status, result } = toolCall
+  const Icon = toolIcons[name] || CodeOutlined
+
+  function renderStatus () {
+    if (status === 'running') {
+      return <LoadingOutlined className='agent-tool-status-running' />
+    }
+    if (status === 'completed') {
+      return <CheckCircleOutlined className='agent-tool-status-completed' />
+    }
+    return <CloseCircleOutlined className='agent-tool-status-error' />
+  }
+
+  function renderTag () {
+    const color = status === 'running' ? 'processing' : status === 'completed' ? 'success' : 'error'
+    return (
+      <Tag color={color} className='agent-tool-tag'>
+        {status}
+      </Tag>
+    )
+  }
+
+  return (
+    <div className={`agent-tool-call-card agent-tool-${status}`}>
+      <div
+        className='agent-tool-header pointer'
+        onClick={() => setExpanded(!expanded)}
+      >
+        {expanded ? <CaretDownOutlined /> : <CaretRightOutlined />}
+        <Icon className='mg1l' />
+        <span className='mg1l agent-tool-name'>{name}</span>
+        {renderTag()}
+        {renderStatus()}
+      </div>
+      {expanded && (
+        <div className='agent-tool-detail'>
+          {args && Object.keys(args).length > 0 && (
+            <div className='agent-tool-args'>
+              <div className='agent-tool-label'>Arguments:</div>
+              <pre className='agent-tool-pre'>{JSON.stringify(args, null, 2)}</pre>
+            </div>
+          )}
+          {result && (
+            <div className='agent-tool-result'>
+              <div className='agent-tool-label'>Result:</div>
+              <pre className='agent-tool-pre'>{formatResult(result)}</pre>
+            </div>
+          )}
+        </div>
+      )}
+    </div>
+  )
+}