@electerm/electerm-react 3.10.0 → 3.11.0

package/client/common/bookmark-schemas.js

@@ -0,0 +1,164 @@
+/**
+ * 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'),
+  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/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>
+  )
+}

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

@@ -0,0 +1,193 @@
+import { z } from '../../common/zod'
+import { bookmarkSchemas } from '../../common/bookmark-schemas'
+
+function buildAddBookmarkParameters () {
+  const typeProperties = {}
+  for (const [type, schema] of Object.entries(bookmarkSchemas)) {
+    typeProperties[type] = z.toJSONSchema(z.object(schema))
+  }
+
+  return {
+    type: 'object',
+    properties: {
+      type: {
+        type: 'string',
+        enum: Object.keys(bookmarkSchemas),
+        description: 'Bookmark type'
+      },
+      ...Object.fromEntries(
+        Object.entries(typeProperties).map(([type, schema]) => [
+          type,
+          { type: 'object', description: `Fields for ${type} bookmark`, ...schema }
+        ])
+      )
+    },
+    required: ['type']
+  }
+}
+
+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.',
+      parameters: {
+        type: 'object',
+        properties: {
+          command: {
+            type: 'string',
+            description: 'The shell command to execute'
+          },
+          tabId: {
+            type: 'string',
+            description: 'Terminal tab ID. Omit to use the active terminal.'
+          }
+        },
+        required: ['command']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'get_terminal_output',
+      description: 'Read the current visible output from a terminal.',
+      parameters: {
+        type: 'object',
+        properties: {
+          tabId: {
+            type: 'string',
+            description: 'Terminal tab ID. Omit for active terminal.'
+          },
+          lines: {
+            type: 'number',
+            description: 'Number of recent lines to read (default 50).'
+          }
+        }
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'open_local_terminal',
+      description: 'Open a new local terminal tab. Returns the new tab ID.',
+      parameters: {
+        type: 'object',
+        properties: {}
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'list_tabs',
+      description: 'List all open terminal tabs with their IDs, titles, hosts, and types.',
+      parameters: {
+        type: 'object',
+        properties: {}
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'get_active_tab',
+      description: 'Get the currently active terminal tab.',
+      parameters: {
+        type: 'object',
+        properties: {}
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'switch_tab',
+      description: 'Switch to a different terminal tab.',
+      parameters: {
+        type: 'object',
+        properties: {
+          tabId: {
+            type: 'string',
+            description: 'The tab ID to switch to.'
+          }
+        },
+        required: ['tabId']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'list_bookmarks',
+      description: 'List all saved bookmarks (SSH, Telnet, VNC, etc.).',
+      parameters: {
+        type: 'object',
+        properties: {}
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'open_bookmark',
+      description: 'Open a saved bookmark as a new terminal tab.',
+      parameters: {
+        type: 'object',
+        properties: {
+          id: {
+            type: 'string',
+            description: 'The bookmark ID to open.'
+          }
+        },
+        required: ['id']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'add_bookmark',
+      description: 'Create a new bookmark. Specify the type and provide type-specific fields. Supported types: ' + Object.keys(bookmarkSchemas).join(', ') + '.',
+      parameters: buildAddBookmarkParameters()
+    }
+  }
+]
+
+export async function executeToolCall (toolName, args) {
+  const store = window.store
+  switch (toolName) {
+    case 'send_terminal_command': {
+      store.mcpSendTerminalCommand(args)
+      const idleResult = await store.mcpWaitForTerminalIdle({
+        tabId: args.tabId || store.activeTabId,
+        timeout: 30000,
+        lines: 100
+      })
+      return JSON.stringify(idleResult)
+    }
+    case 'get_terminal_output':
+      return JSON.stringify(store.mcpGetTerminalOutput(args))
+    case 'open_local_terminal':
+      return JSON.stringify(store.mcpOpenLocalTerminal())
+    case 'list_tabs':
+      return JSON.stringify(store.mcpListTabs())
+    case 'get_active_tab':
+      return JSON.stringify(store.mcpGetActiveTab())
+    case 'switch_tab':
+      return JSON.stringify(store.mcpSwitchTab(args))
+    case 'list_bookmarks':
+      return JSON.stringify(store.mcpListBookmarks())
+    case 'open_bookmark':
+      return JSON.stringify(store.mcpOpenBookmark(args))
+    case 'add_bookmark': {
+      const { type } = args
+      const typeFields = args[type] || {}
+      return JSON.stringify(await store.mcpAddBookmark({ type, ...typeFields }))
+    }
+    default:
+      throw new Error(`Unknown agent tool: ${toolName}`)
+  }
+}