Automated ssh terminal system including a secure bridge between a remote ai agent and local resources

Abstract

An automated SSH terminal system is provided that includes a security bridge between a remote AI agent and a local resource, and includes a user terminal comprising: a development server on which an AI agent is running and a core engine that connects the AI ​​agent of the development server with an OS (Operating System); an SSH connection unit that creates a Secure Shell (SSH) session and connects to the development server when a connection to the development server is requested; an MCP execution unit that runs at least one pre-configured Model Context Protocol (MCP) server; a relay connection unit that runs a relay server to connect at least one MCP server to the development server; an integration unit that integrates at least one MCP server; and an access configuration unit that sets the AI ​​agent of the development server to call the MCP tool of the MCP server by exposing the port of the relay server to the development server via SSH reverse forwarding.

Description

Technology Field

[0001] The present invention relates to an automated SSH terminal system comprising a security bridge between a remote AI agent and a local resource, and provides a system that enables a remote AI agent to access a client's local resource under a security policy. Background Technology

[0002] With the proliferation of remote development environments and AI-based automation technologies, developers are increasingly performing tasks by utilizing various programs and AI agents running on remote development servers. However, SSH-based remote access methods are limited to a simple command transmission structure between the user terminal and the development server, which restricts AI agents running in the remote environment from directly accessing or utilizing local resources such as files, the screen, and the clipboard on the user terminal. Furthermore, the lack of systematic security controls and user authorization structures for accessing local resources makes it difficult to simultaneously ensure both scalability and security in remote automation environments. Consequently, there is a growing need for a new type of system architecture that enables mutual interaction between remote AI agents and local resources on the user terminal while maintaining security.

[0003] At this time, methods for connecting a client and a server via SSH tunneling or collecting environment information through SSH-based remote access have been researched and developed. In this regard, prior art Korean Published Patent No. 2025-0076295 (published May 29, 2025) and Korean Registered Patent No. 10-2614060 (published December 15, 2023) disclose a configuration that controls user access and manages connection history through a structure including a web server, a connection server, and a log server when verifying authentication and authorization for a user terminal's request to access a cloud service, and then relaying a connection with a cloud server using SSH tunneling to control access; and a configuration that collects environment information through SSH-based remote access and visualizes the entire system structure by performing source code function tagging and connection information analysis when converting an existing application into a Software as a Service structure based on the derived connection relationships between services by collecting and analyzing the application's execution environment and source code.

[0004] However, in the former case, only a configuration is disclosed that verifies the cloud service access rights of the user terminal using a DB server, web server, and connection server and performs a connection via SSH tunneling; it does not disclose a configuration of a security bridge that operates within the user terminal and controls the remote AI agent's access to local resources based on user authorization. In the latter case as well, only a configuration is disclosed that analyzes the application's source code to derive call relationships between functions and visualizes the system structure; it does not include a configuration of a security bridge that relays access to the user terminal's local resources in response to a request from the remote AI agent. Accordingly, research and development of a system capable of simultaneously implementing secure linkage between the remote AI agent and local resources and user authorization-based control is required. The problem to be solved

[0005] One embodiment of the present invention provides an automated SSH terminal system including a security bridge between a remote AI agent and local resources, which can simultaneously improve security and usability by allowing an AI agent running on a remote development server to directly access and utilize local resources of a user terminal while controlling access based on user approval through a security bridge; improve system scalability by utilizing a protocol conversion structure through a local MCP server and a relay server, thereby allowing local functions to be extended like network-based services while maintaining the existing SSH environment; and significantly improve development and operational convenience by automatically recognizing the port and URL of the development server based on output information from the SSH terminal and linking port forwarding with browser execution. However, the technical problem that this embodiment aims to solve is not limited to the technical problem described above, and other technical problems may exist. means of solving the problem

[0006] As a technical means for achieving the technical problem described above, one embodiment of the present invention includes a user terminal comprising: a development server on which an AI agent is run and a core engine that connects the AI ​​agent of the development server and an OS (Operating System); an SSH connection unit that creates an SSH (Secure Shell) session and connects to the development server when a connection to the development server is requested; an MCP execution unit that executes at least one pre-configured MCP (Model Context Protocol) server; a relay connection unit that executes a relay server to connect at least one MCP server to the development server; an integration unit that integrates at least one MCP server; and an access setting unit that sets the AI ​​agent of the development server to call the MCP tool of the MCP server by exposing the port of the relay server to the development server through SSH reverse forwarding. Effects of the invention

[0007] According to any one of the means for solving the problem of the present invention described above, scalability is improved by enabling a remote AI agent to utilize the functions of the user terminal as a network service through an MCP relay protocol structure that converts STDIO communication of an MCP server within the user terminal into HTTP-based communication, and security regarding access to local resources can be secured through a two-layer security approval system composed of a policy engine and a user approval UI. Development convenience can be improved by recognizing a framework based on SSH PTY output analysis, automatically detecting the port of the development server, and linking port forwarding and browser execution. Work efficiency is increased by automating data exchange between the user terminal and the remote development server through a native clipboard-based multi-file transfer system and a screen capture and remote transfer pipeline, and session stability and system flexibility can be improved through a Headless session engine architecture separated from the UI. Brief explanation of the drawing

[0008] FIG. 1 is a diagram illustrating an automated SSH terminal system including a security bridge between a remote AI agent and a local resource according to an embodiment of the present invention. FIG. 2 is a block diagram for explaining a user terminal included in the system of FIG. 1. FIGS. 3 and 4 are drawings for illustrating an embodiment in which an automated SSH terminal solution is implemented, including a security bridge between a remote AI agent and a local resource according to an embodiment of the present invention. FIG. 5 is a flowchart illustrating a method for providing an automated SSH terminal solution including a security bridge between a remote AI agent and a local resource according to an embodiment of the present invention. Specific details for implementing the invention

[0009] Embodiments of the present invention are described below with reference to the attached drawings so that those skilled in the art can easily implement the invention. However, the present invention may be embodied in various different forms and is not limited to the embodiments described herein. Furthermore, in order to clearly explain the present invention in the drawings, parts unrelated to the explanation have been omitted, and similar parts throughout the specification are denoted by similar reference numerals.

[0010] Throughout the specification, when a part is described as being "connected" to another part, this includes not only cases where they are "directly connected" but also cases where they are "electrically connected" with other elements interposed between them. Furthermore, when a part is described as "including" a component, this means that, unless specifically stated otherwise, it does not exclude other components but may include additional components, and it should be understood that this does not preclude the existence or addition of one or more other features, numbers, steps, actions, components, parts, or combinations thereof.

[0011] Terms such as “about,” “substantially,” etc., used throughout the specification, are used to mean at or near the stated value when inherent manufacturing and material tolerances are presented in the stated meaning, and are used to prevent unscrupulous infringers from unfairly exploiting the disclosure in which precise or absolute values ​​are mentioned to aid in understanding the invention. Terms such as “step” or “step of” used throughout the specification of the invention do not mean “step for”.

[0012] In this specification, the term "part" includes a unit realized by hardware, a unit realized by software, and a unit realized using both. Additionally, one unit may be realized using two or more pieces of hardware, and two or more units may be realized by one piece of hardware. Meanwhile, "part" is not limited to software or hardware, and "part" may be configured to reside in an addressable storage medium or configured to run on one or more processors. Accordingly, as an example, "part" includes components such as software components, object-oriented software components, class components, and task components, as well as processes, functions, attributes, procedures, subroutines, segments of program code, drivers, firmware, microcode, circuits, data, databases, data structures, tables, arrays, and variables. The functions provided within the components and "parts" may be combined into a smaller number of components and "parts" or further separated into additional components and "parts." In addition, the components and '~parts' may be implemented to play one or more CPUs within the device or secure multimedia card.

[0013] Some of the operations or functions described herein as being performed by a terminal, device, or device may instead be performed by a server connected to said terminal, device, or device. Likewise, some of the operations or functions described as being performed by a server may also be performed by a terminal, device, or device connected to said server.

[0014] In this specification, some of the operations or functions described as mapping or matching with a terminal may be interpreted as meaning mapping or matching the terminal's unique number or personal identification information, which is the terminal's identifying data.

[0015] The present invention will be described in detail below with reference to the attached drawings.

[0016] FIG. 1 is a diagram illustrating an automated SSH terminal system including a security bridge between a remote AI agent and a local resource according to an embodiment of the present invention. Referring to FIG. 1, the automated SSH terminal system (1) including a security bridge between a remote AI agent and a local resource may include at least one user terminal (100) and a development server (300). However, since the automated SSH terminal system (1) including a security bridge between a remote AI agent and a local resource of FIG. 1 is merely an embodiment of the present invention, the present invention is not to be interpreted as being limited by FIG. 1.

[0017] At this time, each component of FIG. 1 is generally connected through a network (Network, 200). For example, as shown in FIG. 1, at least one user terminal (100) can be connected to a development server (300) through the network (200). And, the development server (300) can be connected to at least one user terminal (100) through the network (200).

[0018] Here, a network refers to a connection structure capable of exchanging information among individual nodes, such as multiple terminals and servers. Examples of such networks include Local Area Networks (LANs), Wide Area Networks (WANs), the World Wide Web (WWW), wired and wireless data networks, telephone networks, and wired and wireless television networks. Examples of wireless data communication networks include, but are not limited to, 3G, 4G, 5G, 3GPP (3rd Generation Partnership Project), 5GPP (5th Generation Partnership Project), 5G NR (New Radio), 6G (6th Generation of Cellular Networks), LTE (Long Term Evolution), WIMAX (World Interoperability for Microwave Access), Wi-Fi, Internet, LAN (Local Area Network), Wireless LAN (Wireless Local Area Network), WAN (Wide Area Network), PAN (Personal Area Network), RF (Radio Frequency), Bluetooth network, NFC (Near-Field Communication) network, satellite broadcasting network, analog broadcasting network, DMB (Digital Multimedia Broadcasting) network, etc.

[0019] In the following, the term "at least one" is defined as a term including both singular and plural forms, and it will be obvious that even if the term "at least one" does not exist, each component may exist in a singular or plural form and may mean singular or plural. Furthermore, whether each component is provided in a singular or plural form may be changed according to the embodiment.

[0020] At least one user terminal (100) may be a terminal of a user that connects to a remote AI agent using a web page, app page, program, or application related to an automated SSH terminal solution including a security bridge between a remote AI agent and a local resource, receives a request from the AI ​​agent, analyzes it with a policy engine, and then executes or rejects it.

[0021] Here, at least one user terminal (100) may be implemented as a computer capable of connecting to a remote server or terminal via a network. Here, the computer may include, for example, a navigation system, a laptop equipped with a web browser, a desktop, a laptop, etc. At this time, at least one user terminal (100) may be implemented as a terminal capable of connecting to a remote server or terminal via a network. At least one user terminal (100) may include all kinds of handheld-based wireless communication devices, such as navigation, PCS (Personal Communication System), GSM (Global System for Mobile communications), PDC (Personal Digital Cellular), PHS (Personal Handyphone System), PDA (Personal Digital Assistant), IMT (International Mobile Telecommunication)-2000, CDMA (Code Division Multiple Access)-2000, W-CDMA (W-Code Division Multiple Access), Wibro (Wireless Broadband Internet) terminal, smartphone, smartpad, tablet PC, etc.

[0022] The development server (300) may be a server that provides an automated SSH terminal solution web page, app page, program, or application that includes a security bridge between a remote AI agent and a local resource. Additionally, the development server (300) may be a server that is connected to a user terminal (100), transmits a request from the AI ​​agent to the user terminal (100), and receives a response. Here, the development server (300) may be implemented as a computer capable of connecting to a remote server or terminal via a network. Here, the computer may include, for example, a laptop, desktop, or laptop equipped with a navigation system or a web browser.

[0023] FIG. 2 is a block diagram for explaining a user terminal included in the system of FIG. 1, and FIG. 3 and FIG. 4 are diagrams for explaining an embodiment in which an automated SSH terminal solution including a security bridge between a remote AI agent and a local resource is implemented according to an embodiment of the present invention.

[0024] Referring to FIG. 2, the user terminal (100) may include a driving unit (110), an SSH connection unit (120), an MCP execution unit (130), a relay connection unit (140), an integration unit (150), an access setting unit (160), a policy application unit (170), an output unit (180), an execution decision unit (190), an automatic port detection unit (191), a multi-file transmission unit (193), and a screen providing unit (195).

[0025] When a development server (300) or another server (not shown) operating in conjunction with an embodiment of the present invention transmits an automated SSH terminal solution application, program, app page, web page, etc., including a security bridge between a remote AI agent and a local resource to at least one user terminal (100), the at least one user terminal (100) may install or open an automated SSH terminal solution application, program, app page, web page, etc., including a security bridge between a remote AI agent and a local resource. Additionally, a service program may be executed on at least one user terminal (100) using a script executed in a web browser. Here, a web browser refers to a program that enables the use of web (WWW: World Wide Web) services and receives and displays hypertext described in HTML (Hyper Text Mark-up Language), and includes, for example, Chrome, Microsoft Edge, Safari, Firefox, Whale, UC Browser, etc. In addition, "application" refers to an application on a terminal, and includes, for example, an app running on a mobile terminal (smartphone).

[0026] Referring to FIGS. 2 to 4, the driving unit (110) can run a core engine that connects the AI ​​agent of the development server (300) and the OS (Operating System). In this case, the OS refers to the operating system of the user terminal (100). The development server (300) may be a server where the AI ​​agent is run. The driving unit (110) can execute a Windows-based UI application, which is a client application, and initialize a core engine that is linked to a terminal screen, a session management screen, an approval dialog, a file explorer, and a settings screen. Here, the core engine is a backend processing module that actually performs the core functions of the system, and is a part responsible for operations such as SSH connection management, session state management, MCP relay processing, agent bridge operation, file transfer, and port forwarding. The aforementioned core engine is a Rust-based headless core engine, which will be described later.

[0027] The frontend is implemented based on Tauri or WebView2, and communication between the core engine and the Windows-based UI application can be performed via Inter-Process Communication (IPC) based JSON-RPC and event streams. Here, IPC refers to communication between processes; since the Windows-based UI application is a frontend such as Tauri or WebView and the core engine is a Rust backend, they are separate processes and cannot communicate directly, so IPC is utilized. JSON-RPC (Remote Procedure Call) is a JSON-based remote function invocation method, an imperative communication technique that sends requests to execute a specific function in JSON format. An event stream is a method of continuously sending events, which transmits them to the Windows-based UI application whenever a state change occurs.

[0028] division JSON-RPC Event stream method Request / Response Real-time notifications direction Two-way Primarily Core Engine → Windows-based UI Applications use Command execution State transfer

[0029] [Windows-based UI Application] ↓ (JSON-RPC Request) [Core Engine] ↓ (Event Stream) [Windows-based UI Application]

[0030] The SSH connection unit (120) can create an SSH (Secure Shell) session and connect to the development server (300) when a connection to the development server (300) is requested. The development server (300) may be, for example, a Linux development server located remotely. Accordingly, when a user at the user terminal (100) requests a connection to the Linux development server located remotely, the SSH connection unit (120) creates a virtual terminal (Pseudo Terminal, PTY) and manages session state transitions to prepare a remote shell execution environment. At this time, the SSH transport layer is implemented using a Rust-based SSH library or a Libssh family, and authentication can be performed using a password, public key, or agent forwarding method. In addition, the management of the virtual terminal (PTY) is performed through a virtual terminal (Pseudo-Terminal) processing module, and session state management can be handled through an Actor model or an asynchronous state machine structure.

[0031] <MCP 릴레이 프로토콜 변환>

[0032] The MCP execution unit (130) can execute at least one pre-configured MCP (Model Context Protocol) server. At this time, the MCP (Model Context Protocol) server is an execution program that provides functions that an AI agent can use, is located on the user terminal (100), and is executed locally on the user terminal (100). It receives requests via JSON-RPC. For example, the MCP server may be a file reading MCP server, a Gmail MCP server, and a DB MCP server.

[0033] MCP server ├─ tool: search_emails ├─ tool: read_file └─ tool: query_db

[0034] The reason the AI ​​agent attempts to access the MCP server is that the AI ​​agent alone cannot read files, access the OS (Operating System), or directly execute external services. For example, if you instruct ChatGPT to read emails, ChatGPT cannot perform this task because it cannot handle external services (emails) independently. However, by connecting an MCP server, it becomes possible to perform functions such as reading files, querying emails, controlling servers, and executing automations. Accordingly, the AI ​​agent uses the MCP server to perform actual tasks. The problem here is that the MCP server runs only locally, and the communication method is as follows.

[0035] stdin / stdout (STDIO)

[0036] In other words, it is a method where network access is impossible. However, since the remote AI agent uses HTTP and can only be accessed via the network, a conflict occurs.

[0037] AI Agent → HTTPMCP Server → STDIO

[0038] In other words, a situation arises where they cannot communicate with each other. Accordingly, one embodiment of the present invention provides protocol conversion and network transmission so that the AI ​​agent of the development server (300) can access the MCP server of the user terminal (100).

[0039] step process explanation Step 1: Protocol Conversion STDIO → HTTP conversion MCP Server (STDIO) ↓ Relay Server (McpRelay) (HTTP Server) Phase 2: Integration Integration of multiple MCP servers gmail / fs / db → a single endpoint Step 3: Network Connection Local → Remote Connection SSH forwarding

[0040] AI Agent (HTTP) ↓ SSH ↓ Relay Server (McpRelay) (HTTP) ↓ MCP Client (McpClient) ↓ MCP Server (STDIO)

[0041] <Step 1: Protocol Conversion>

[0042] The relay connection unit (140) can run a relay server that connects at least one MCP server to the development server (300). That is, the first step among the steps described above is a protocol conversion step, and can run a relay server that converts the STDIN / STDOUT communication of the process of the MCP server running locally into an HTTP JSON-RPC endpoint.

[0043] [Local MCP Server Process] ↓ STDIN / STDOUT(JSON-RPC 2.0)[STDIOTransport] ← Process Lifecycle Management ↓[MCP Client] ← Caching Tools / Resources / Prompt Lists ↓[Relay Server] ← localhost:9800 ↓ HTTP POST / MCP(JSON-RPC 2.0)

[0044] STDIOTransport creates an MCP server process as a child process, writes JSON-RPC requests to STDIN, and reads responses from STDOUT. Here, STDIOTransport is a module that communicates with the program via STDIN and STDOUT. Programs fundamentally have two channels: STDIN is input (what the program receives), and STDOUT is output (what the program sends out). STDIOTransport is the code (module) that manages this STDIN / STDOUT communication. STDIOTransport executes the MCP server program internally and communicates with it through input and output channels; simply put, it can be said that after running the MCP server, it sends requests via input (STDIN) and receives results via output (STDOUT).

[0045] Additionally, a unique ID is assigned to each request, and request-response matching is performed using the Pending_Responses hash map. In other words, since multiple requests can be processed simultaneously, a number (ID) is assigned to each request, allowing the response to be located and connected using that number. Subsequently, if the MCP server process terminates, a Graceful Shutdown (forced termination after a 5-second timeout) can be performed. That is, when shutting down the MCP server, a graceful shutdown is attempted first, and if it does not terminate within a certain time, it can be forcibly shut down.

[0046] <Phase 2: Integration>

[0047] The integration unit (150) can integrate at least one MCP server. By unifying multiple MCP servers into a single interface, a remote AI agent can call various functions with only one endpoint, eliminate the complexity of individual connection and configuration for each MCP server, and improve the efficiency of tool exploration, calling, and management.

[0048] [HTTP Request: tools / call "gmail.search_emails"] ↓[Router (MCP Router)] ← MCP Tools - MCP Server ID Mapping Table ↓ Routing based on MCP Server Name Prefix [Registry (MCP Registry)] ← MCP Server ID - MCP Client Mapping ↓[Request forwarded to the corresponding MCP server]

[0049] The MCP Router is a distribution module that determines which MCP server a requested MCP tool should be executed on and forwards it to that server. To this end, it may include a mapping table such as [MCP Server ID - MCP Tool]. Furthermore, the router collects and centrally manages lists of MCP tools, resources, and prompts from all registered MCP servers. If functions with the same name exist, it automatically assigns a prefix in the format [MCP Server ID - MCP Tool] to prevent conflicts. Additionally, it can provide integrated functionality so that remote AI agents recognize it as a single MCP server (Agentic Terminal MCP Hub) rather than multiple MCP servers.

[0050] Request: gmail.search_emails ↓ Router (MCP Server ID - MCP Tool) ↓ Determines "gmail" must be sent to MCP server ↓ Forwarded to the corresponding MCP server

[0051] In this case, the MCP tool is gmail.search_emails, and the MCP server ID is gmail. Since [MCP server ID-MCP tool] is stored in the mapping table, the router can determine where to send the AI ​​agent's request by looking at this mapping table. Here, an MCP tool is an individual execution function (function-unit task) provided by the MCP server.

[0052] MCP Server ├─ MCP Tool: search_emails ├─ MCP Tool: send_email └─ MCP Tool: get_email

[0053] MCP server MCP tools Gmail server search_emails, send_email file server read_file, write_file DB server query_db

[0054] Accordingly, the configuration and calling structure of a remote AI agent can be simplified by allowing the AI ​​agent to recognize that all functions are provided collectively through a single MCP server (Agentic Terminal MCP Hub) without the need to recognize multiple MCP servers individually.

[0055] If there are multiple MCP servers, complexity increases dramatically because the AI ​​agent must know about the Gmail server, file server, DB server, and Slack server separately, connect to each one, and manage a separate list of MCP tools. However, when integrated, as shown in Table 13, the AI ​​agent only needs to know about a single MCP server and send requests to it. This is because the router automatically distributes the requests. Consequently, configuration and calls are simplified, and scalability is improved because the AI ​​agent remains unchanged even if additional MCP servers are added.

[0056] Agentic Terminal MCP Hub (appears as a single MCP server) ├─ gmail.search_emails ├─ fs.read_file ├─ db.query └─ slack.send_message

[0057] If you have integrated the MCP servers to appear as one, you must now connect the network as follows.

[0058] <Step 3: Network Connection>

[0059] The access setting unit (160) can be configured so that the AI ​​agent of the development server (300) calls the MCP tool of the MCP server by exposing the port of the relay server to the development server (300) via SSH reverse forwarding. That is, the port of the development server (300) can be connected to the relay server of the user terminal (100) using SSH. This is accomplished by an SSH tcpip-forward request, which means a command requesting a port connection (forwarding). Since the development server (300) cannot be accessed by the user terminal (100), a tunnel is created via SSH to establish the connection.

[0060] At this time, SSH reverse port forwarding is a technique that connects a specific port of the development server (300) to a port of the user terminal (100), that is, the local PC.

[0061] division direction General forwarding Local → Remote Reverse forwarding Remote → Local

[0062] The reason for using this is that, as described above, a local PC such as a user terminal (100) cannot be accessed from the outside for security reasons, so it is accessed by bypassing through a development server (300).

[0063] [AI Agent (Development Server (300))] ↓ http: / / localhost:9800 [Development Server (300) Port 9800] ↓ (SSH Reverse Forwarding) ↓ [User Terminal (100) Port 9800] ↓ [Local Relay Server (MCP Relay) (9800)] ↓ [MCP Server]

[0064] That is, the AI ​​agent does not connect directly to the local PC, but only accesses the port of the development server (300), but since the actual execution occurs on the user terminal (100), which is the local PC, the AI ​​agent can, as a result, access the local PC (remote port → local program). At this time, the mcp_setup_remote_access command automatically performs the execution of the relay server and the SSH reverse forwarding settings as a single task, and accordingly, the remote AI agent can access all MCP tools provided by multiple MCP servers existing locally by sending only an HTTP request to localhost:9800 without separate network settings. The mcp_setup_remote_access command is an automatic configuration command to enable the AI ​​agent to use the MCP server; when executed, the relay server is executed and SSH reverse forwarding is configured. Originally, the relay server had to be turned on separately and SSH forwarding had to be configured separately, but since this is cumbersome, a command that performs everything at once has been set up and saved.

[0065] In one embodiment of the present invention, "local" refers to a user terminal (100), that is, a computer currently in use. In this case, "localhost" is an address pointing to my computer. Also, according to one embodiment of the present invention, "remote" refers to a development server (300).

[0066] Local remote User terminal (100) Development server (300)

[0067] Through the above-described configuration, the remote AI agent can access multiple local MCP servers (Gmail, Slack, Notion, etc.) without installing separate additional software. Furthermore, by converting MCP servers that previously operated only in STDIO mode to be accessible via a network and integrating them into a single endpoint, the complexity of configuring and operating the remote AI agent can be reduced.

[0068] Layer 2 Security Approval

[0069] Accessing local PC resources, such as screens, files, clipboards, and browsers, by a program on a development server (300) entails serious security risks. Since there is no systematic security model for such reverse access in the prior art, one embodiment of the present invention aims to provide a security approval system composed of two layers: a policy engine and an approval UI.

[0070] <Layer 1: Request-based Policy Engine>

[0071] Layer 1 is a request-based policy engine, which is defined as shown in Table 17 below.

[0072] Request Definition: ├── ScreenCapture-Screen Capture ├── FileUpload-File Upload ├── BrowserOpen-Open Browser URL ├── ClipboardRead-Read Clipboard ├── ClipboardWrite-Write Clipboard └── NotifyShow-Show Notification

[0073] That is, requests may include ScreenCapture, FileUpload, BrowserOpen, ClipboardRead, ClipboardWrite, and NotifyShow, but the types are not limited to those listed and are not excluded for reasons not listed.

[0074] At this time, the policy engine's evaluation of a request can be one of Automatic Allow (Allow), Automatic Deny (Deny), or User Confirmation (Ask). This policy engine evaluates requests using a four-level priority system, which can have the following priorities: [1. Runtime One-time Override (Highest Priority) - 2. Session-specific Policy (Rules set to Session Allow) - 3. Host-specific Policy (Wildcard Pattern Matching: *.company.internal) - 4. Global Default Policy (Lowest Priority)]. Here, Runtime One-time Override means allowing or blocking only once; Session-specific Policy means applying only during the currently connected session; Host-specific Policy refers to rules for specific servers, such as allowing company servers; and Global Default Policy refers to rules set by default, such as blocking by default. The aforementioned priorities determine the order in which rules are applied first when there are multiple security rules.

[0075] <Tier 2: User Consent Interface>

[0076] When the policy application unit (170) receives a request from the AI ​​agent of the development server (300), it can evaluate the request in the pre-established policy engine. The output unit (180) can output an approval request if the result of the evaluation of the request is user confirmation. That is, if the policy engine determines [ASK], an approval dialog box is displayed as shown in Table 18.

[0077] Approval Request MCP Tool: search_emails MCP Server: gmail Arguments: query="subject:requirement" [One-time Allow] [Session Allow] [Deny]

[0078] In this case, the approval request is provided as a one-time allowance that permits only once, a session allowance that automatically permits the same request during the same session, and a denial that rejects the request, allowing the user to select one of the inputs.

[0079] Pending → WaitingApproval → Executing → Completed │ ↑ └──── Denied ─-───┘

[0080] The execution decision unit (190) can determine whether to execute the request of the AI ​​agent based on the input of the approval request. When executed, all requests and decisions can be recorded in an audit log along with the host, execution capability, decision details, and timestamp. Through the above configuration, access to local resources by the remote AI agent can be finely controlled, user convenience can be improved by applying session-based automatic approval for repetitive requests, host-specific policies and global policies can be separated to satisfy various security requirements of the enterprise environment, and tracking and analysis can be performed based on the audit log when security events occur.

[0081] The process described above can be organized into steps as shown in Table 20 below. Of course, steps can be added, deleted, or changed, so the order is not limited to that of Table 20.

[0082] step process tool or model 1. Launch client application and initialize core engine Initializes a Rust-based Headless core engine that runs Windows UI applications and interacts with the terminal screen, session management screen, approval dialog, file explorer, and settings screen. The frontend uses a UI based on Tauri or WebView2, the core engine is implemented in Rust, and communication between the UI and the core uses IPC-based JSON-RPC and event streams. 2. Creating an SSH Session and Connecting to the Development Server When a user requests access to a remote Linux development server, the session manager prepares the remote shell execution environment by performing SSH connection, authentication, PTY creation, and session state transitions. The SSH transport layer uses the Rust SSH library or the libssh family; authentication can use password, public key, or agent forwarding methods; PTY management uses a pseudo-terminal processing module; and session state management is implemented using an Actor model or an asynchronous state machine. 3. Run local MCP server and establish STDIO communication Run multiple MCP server processes on the local device and establish a foundation for accessing local tools by connecting each server with a stdin / stdout-based JSON-RPC communication channel. MCP server process management uses Rust process spawning, STDIO I / O control uses async process I / O, JSON-RPC 2.0 message processing uses serde_json or an equivalent serialization library, and request-response matching uses a HashMap-based pending response structure. 4. Start MCP STDIO-HTTP Relay Server Run a relay server that converts the local MCP server's STDIO communication into an HTTP JSON-RPC endpoint to enable network-based access. The HTTP server can use one of Axum, Hyper, or Actix Web, configures a JSON-RPC bridging module, and uses graceful shutdown logic and timeout control for process lifecycle management. 5. MCP Multi-Server Routing and Consolidation Hub Configuration Collects lists of tools, resources, and prompts provided by multiple MCP servers, identifies servers based on tool names, and integrates and exposes them like a single MCP hub. Routing logic is implemented using the McpRouter structure, server registration management uses the Registry pattern, name conflict prevention is handled by assigning server name prefixes, and metadata caching uses an in-memory cache. 6. Setting up remote MCP access via SSH reverse forwarding By exposing the local MCP relay port to the development server via SSH reverse forwarding, remote AI agents can call local MCP tools using only the localhost address. Uses SSH reverse port forwarding, handles tcpip-forward requests, the SSH forwarding module is responsible for port mapping and connection maintenance, and detects connection anomalies via heartbeat or session status events. 7. Receiving remote AI agent requests and relaying via Agent Bridge When an AI agent running on the development server requests access to local resources such as screen capture, file upload, browser opening, or clipboard reading, the Agent Bridge receives the request and connects it to the appropriate local workflow. When an AI agent running on the development server requests access to local resources such as screen capture, file upload, browser opening, or clipboard reading, the Agent Bridge receives the request and connects it to the appropriate local workflow. 8. Policy Engine-Based Primary Security Assessment For the requested Capability, priority is evaluated in the order of global default policy, host-specific policy, session-specific policy, and runtime override to determine whether to automatically allow, deny, or verify the user. For the requested Capability, priority is evaluated in the order of global default policy, host-specific policy, session-specific policy, and runtime override to determine whether to automatically allow, deny, or verify the user. 9. User Approval UI-based Secondary Security Approval If the policy result is Ask, display an approval dialog in the UI and allow the user to select one of Allow Once, Allow Session, or Deny to determine whether to execute the final policy. The approval UI is implemented using a Tauri frontend or a React-based modal, event delivery uses an IPC event bus, and approval results are reflected in the session policy override repository.

[0083] Automatic Port Detection

[0084] When a development server (300) such as Next.js, Vite, or Django is executed, the service starts on a port such as localhost:3000, but it cannot be accessed directly from a browser on a local PC, and there is the inconvenience of the user having to manually set up port forwarding and check the open ports. To solve this, the present invention can provide a system that automatically detects the execution of a development server (300) by analyzing the standard output (STDOUT) stream of a virtual terminal (Pseudo Terminal, PTY) in real time.

[0085] To this end, the automatic port detection unit (191) analyzes the standard output stream of the virtual terminal (pseudo terminal) of SSH in real time to automatically recognize the port of the development server (300), outputs to the screen a request for port forwarding for the port to the user, and when the port forwarding is approved, sets up port forwarding and can launch a browser.

[0086] In order to automatically detect ports, in one embodiment of the present invention, ① various forms of server start messages can be detected by multi-stage regular expression matching using a pattern detection engine.

[0087] Pattern Type 1 - Direct URL Detection "http: / / localhost:3000""http: / / 127.0.0.1:5173""https: / / 0.0.0.0:8080" Pattern type 2-port listening message "listening on port 8080""server started on port 3000" Pattern Type 3 - Messages by Framework "Local: http: / / localhost:5173 / " → Vite "ready on http: / / localhost:3000" → Next.js "Starting development server at ..." → Django "Listening on http: / / 127.0.0.1:8000" → FastAPI / Uvicorn

[0088] Then, ② the framework name can be extracted from the detected output text (automatic framework identification) to provide a meaningful label to the user.

[0089] Detection keywords Identification Framework `next` Next.js `vite` Vite `nuxt` Nuxt `django` Django `flask` Flask rails Rails `spring` Spring Boot `express` Express `fastapi` FastAPI uvicorn Uvicorn

[0090] ③ Then, already detected ports can be recorded in a HashSet to prevent repeated notifications for the same port (prevention of duplicate detection). At this time, the detection result events may be as shown in Table 23 below, for example.

[0091] dev_endpoint.detected { session_id: "sess_abc123", remote_host: "127.0.0.1", remote_port: 3000, scheme: "http", label: "Next.js"}

[0092] ④ When a detection result event is received, the Window-based UI application suggests port forwarding to the user, and if the user [approves] it can automatically set up port forwarding and launch a browser.

[0093] If, ⑤ port forwarding is performed but the local port is already in use, i.e., if the port conflicts, a policy as shown in Table 24 below may be used.

[0094] Exact Use only requested ports (error on failure) `FallbackNext` Search in the order of request port → +1 → +2 (default) RandomEphemeral OS allocates arbitrary available ports

[0095] When using the method described above, there is no need to manually configure port forwarding when running the development server (300). Additionally, the user experience can be improved by automatically identifying the framework name, and since it operates in a non-invasive manner that manually analyzes the output information of the virtual terminal (Pseudo Terminal, PTY), it has the advantage of not affecting the process running on the development server (300).

[0096] step process tool or model Development server output detection and automatic port recognition It analyzes the stdout stream of the SSH PTY in real-time to detect development server execution messages, URLs, port numbers, and framework identification strings, and automatically identifies development endpoints. Stdout stream parsing uses an async stream parser, pattern recognition uses the Regex regular expression engine, framework determination is handled by a keyword rule base or label mapping table, and duplicate prevention uses a HashSet-based port log structure. Automatic port forwarding suggestions and browser integration For the detected development port, the UI suggests port forwarding to the user, and if approved, creates an SSH local forwarding according to the local port assignment policy and launches the browser. SSH local port forwarding is used, local port conflict handling is implemented using Exact, FallbackNext, and RandomEphemeral policies, and browser launch is performed using the OS shell open or Tauri shell API.

[0097] <Multiple File Transfer>

[0098] In the WebView2 (Chromium-based web view) environment, due to limitations of the web standard Clipboard API, a list of multiple files copied from Windows Explorer cannot be read normally, and only one file can be accessed through clipboardData.files, and the full file path is not provided for security reasons. To solve this, the present invention utilizes the native command system of Tauri (a Rust-based desktop framework) to directly read the CF_HDROP format of the Windows clipboard to obtain a list of multiple files and the full path.

[0099] Accordingly, the multi-file transfer unit (193) can receive a list of all file paths stored in the native clipboard through the native command system of the desktop framework built to read multiple files copied from the Windows Explorer of the user terminal (100), and can transfer multiple files to the development server (300) by sequentially uploading multiple files to SFTP (Secure File Transfer Protocol) based on the list of all file paths.

[0100] Here, the CF_HDROP (Clipboard Format Handle Drop) format refers to a data format that holds a list of files in the Windows clipboard. In other words, if you copy file1.txt, file2.csv, and file3.png in Windows Explorer, they appear in the Windows clipboard as C:\test\file1.txt, C:\test\file2.csv, and C:\test\file3.png; this format is the CF_HDROP format. While the web method only reads a single file, using the native method—that is, by directly reading the CF_HDROP—allows for multiple files and enables the acquisition of their full paths.

[0101] Web Clipboard API Windows CF_HDROP Restricted (Security) Full file information available

[0102] [User: Select 3 files in Windows Explorer and press Ctrl+C] ↓ [Enter Ctrl+V in SSH Terminal] ↓ [Windows UI Application: Detect clipboardData.files → Verify file existence] ↓ [Tauri IPC: Call get_clipboard_files() native command] ↓ [Core Engine (Rust): Read CF_HDROP format using clipboard-win crate] ↓ Return full list of file paths: ["C:\docs\file1.pdf", "C:\docs\file2.pdf", "C:\docs\file3.pdf"] ↓ [Upload each file sequentially via SFTP] ↓ [All files uploaded to development server complete]

[0103] As described above, CF_HDROP is a clipboard format that stores a list of files in the Windows Shell and includes full path information for each file. Accordingly, the present invention is configured to read it directly at the native OS layer to bypass the limitations of the Web Clipboard API. In addition, if reading the CF_HDROP format fails, an automatic fallback is performed by using the Web Clipboard API. Accordingly, multiple files copied from Windows Explorer can be uploaded to the development server (300) with a single paste operation, clipboard limitations in the WebView2 environment can be resolved through the native API, and if an image is copied, it can be automatically converted to PNG format to support uploading.

[0104] step process tool or model Collection of native clipboard file lists When a user pastes multiple files copied from Windows Explorer into the terminal, the existence of the files is detected using the Web Clipboard API, and the list of full file paths is obtained by directly reading the CF_HDROP format in the native layer. The UI layer uses the Clipboard API, native calls use Tauri commands, Windows clipboard access uses clipboard-win or Win32 APIs, and file path extraction uses the CF_HDROP parser. Multi-file SFTP upload and remote reflection Upload each file to a remote server sequentially or in parallel based on multiple acquired file paths, and display the upload progress and completion status in the UI. File transfer uses SFTP, the transfer manager module manages the upload queue, a byte-based progress tracker is used for progress calculation, and retry and fallback logic can be implemented in case of failure.

[0105] Screen Capture and Remote Transmission

[0106] In cases where a remote AI agent needs to check a user screen, such as for UI debugging or visual feedback, the prior art required a multi-step procedure in which the user had to take a screenshot, save it as a file, and then upload it. To solve this, one embodiment of the present invention provides a pipeline (screen capture → encoding → upload → path insertion) that performs a series of processes from screen capture to PNG encoding, SFTP upload, and path insertion in a single command.

[0107] Accordingly, when the screen providing unit (195) needs to check the screen of the user terminal (100) from the AI ​​agent, it receives a screen capture from the AI ​​agent, evaluates the screen capture in a pre-established policy engine, outputs an approval request if the result of the evaluation of the screen capture is user confirmation, executes the screen capture if the input for the approval request is allowed, and encodes the screen-captured image and uploads it via SFTP (Secure File Transfer Protocol) so that it can be delivered to the AI ​​agent.

[0108] Capture mode mode movement Filtering `fullscreen` Main monitor full screen capture doesn't exist active_window Capture only the currently active window Exclude minimized windows and zero-size windows

[0109] When a remote AI agent requests a screen capture, the process is executed in the following order in conjunction with the agent bridge.

[0110] 1. The Agent Bridge receives the request. 2. The Policy Engine inspects the ScreenCapture request. 3. The screen capture is executed upon user approval. 4. The PNG bytes are Base64 encoded. 5. The result is included in the AgentResponse and returned to the remote AI agent.

[0111] Through the configuration described above, one embodiment of the present invention enables the processes of screen capture, upload, and path insertion to be performed collectively with a single shortcut key input, and allows an AI agent to programmatically request screen capture. Additionally, unauthorized capture can be prevented based on security policies.

[0112] step process tool or model Screen capture and remote transmission processing Capture the entire screen or active window based on a request from an AI agent or user, encode it into PNG, and transmit it to a remote agent or remote server via Base64 or file upload. Capture the entire screen or active window based on a request from an AI agent or user, encode it into PNG, and transmit it to a remote agent or remote server via Base64 or file upload.

[0113] Headless Session Engine

[0114] SSH terminals according to the prior art have a problem in which the user interface and session logic are tightly coupled, resulting in session loss or difficulty in replacing with a different UI frontend when a UI crash occurs. To solve this, the present invention designs a Rust-based core engine as a headless session engine so that it can operate independently even when separated from the user interface.

[0115] Accordingly, the core engine can be designed as a headless session engine. The core engine can operate independently, separated from the UI (User Interface) application running on the user terminal (100).

[0116] Core Design Principles division Design principles detail 1 Separation of status ownership The core engine manages session state, terminal state, forwarding state, and policy state, while the UI performs only screen display and user input collection. 2 Separation of Data Plane and Control Plane The Data Plane handles standard input (STDIN) and standard output (STDOUT) of the virtual terminal (Pseudo Terminal, PTY), ANSI streams, and screen buffer updates, while the Control Plane handles session creation and termination, forwarding management, file transfers, and permission requests. 3 Event-driven structure It operates in a structure where the core engine publishes events and the UI subscribes to them, transmitting state changes through events such as session.connected, session.disconnected, terminal.screen_updated, terminal.title_changed, transfer.progress, transfer.completed, agent.approval_required, forward.active, and forward.error. 4 Session-based Actor model Each SSH session is managed as an independent Actor, where the SessionActor(session_id) contains the SSH connection, PTY, forwarding, and transport context, and isolates state between sessions to prevent an error in one session from affecting others.

[0117] Session state machine [Created] ↓[Connecting] ↓[Authenticating] ↓[StartingPty] ↓[Running] │ ├────────────→ [Disconnected] │ ↓ │ [Reconnecting] │ ↓ │ [Running] │ ├────────────→ [Failed] │ └────────────→ [Closed]

[0118] Due to the configuration described above, one embodiment of the present invention allows the core engine to be reused even when user interface technology changes, such as switching from React to Flutter, thereby improving system scalability and facilitating easy extension to macOS or mobile clients. Additionally, it has the effect of protecting SSH sessions even if a crash occurs in the user interface and enabling extension to an architecture that allows multiple clients to connect simultaneously.

[0119] Although one embodiment of the present invention has been described based on Windows, it is based on a Headless architecture in which the user interface and the core engine are separated, and is not dependent on a specific operating system or UI technology. Accordingly, it is made clear that it can operate identically on macOS as well as Windows.

[0120] One embodiment of the present invention enables the automation of protocol conversion by automatically converting a STIDO-based MCP server into an HTTP-based relay server, thereby allowing access to local MCP tools in a remote environment without the installation of additional software. Furthermore, by providing granular security control and session-based automatic approval simultaneously through a two-tier approval system, a balance between security and convenience can be secured. Additionally, the ports of the development server can be automatically detected without affecting remote processes by manually analyzing the output streams of a virtual terminal (Pseudo Terminal, PTY). Moreover, operating system limitations can be overcome by resolving clipboard constraints in the WebView2 environment at the native API layer, and development productivity can be improved by eliminating workflow disconnection between remote AI agents and local resources. Security requirements of an enterprise environment can be met through a capability-based policy engine and audit logs, and the development environment can be integrated by integrating SSH terminals, file transfers, port forwarding, MCP integration, and AI agent bridges into a single application.

[0121] As for the details not described in the method for providing an automated SSH terminal solution including a security bridge between a remote AI agent and a local resource as shown in FIGS. 2 to 4, they are identical to or can be easily inferred from the details described above regarding the method for providing an automated SSH terminal solution including a security bridge between a remote AI agent and a local resource through FIG. 1, so further explanation is omitted.

[0122] FIG. 5 is a diagram illustrating the process of transmitting and receiving data between each component included in an automated SSH terminal system comprising a security bridge between a remote AI agent and a local resource according to an embodiment of the present invention. Hereinafter, an example of the process of transmitting and receiving data between each component will be described through FIG. 5, but the present invention is not to be interpreted as being limited to such an embodiment, and it is obvious to those skilled in the art that the process of transmitting and receiving data illustrated in FIG. 5 may be modified according to various embodiments described above.

[0123] Referring to FIG. 5, the user terminal runs a core engine that connects the AI ​​agent of the development server and the OS (Operating System) (S5100).

[0124] And, when a user terminal requests a connection to a development server, it creates an SSH (Secure Shell) session and connects to the development server (S5200), runs at least one pre-configured MCP (Model Context Protocol) server (S5300), and runs a relay server to connect at least one MCP server to the development server (S5400).

[0125] Additionally, the user terminal integrates at least one MCP server (S5500), and then exposes the port of the relay server to the development server via SSH reverse forwarding so that the AI ​​agent of the development server calls the MCP tool of the MCP server (S5600).

[0126] The order of the steps described above (S5100–S5600) is merely an example and is not limited thereto. That is, the order of the steps described above (S5100–S5600) may vary, and some of these steps may be executed simultaneously or deleted.

[0127] As for the details regarding the method for providing an automated SSH terminal solution including a security bridge between a remote AI agent and a local resource as described in Fig. 5, the details that are not described are identical to or can be easily inferred from the details described above regarding the method for providing an automated SSH terminal solution including a security bridge between a remote AI agent and a local resource through Figs. 1 to 4, so further explanation will be omitted.

[0128] A method for providing an automated SSH terminal solution including a security bridge between a remote AI agent and a local resource according to an embodiment described through FIG. 5 may also be implemented in the form of a recording medium containing computer-executable instructions, such as an application or program module executed by a computer. The computer-readable medium may be any available medium accessible by a computer and includes both volatile and non-volatile media, and both removable and non-removable media. Additionally, the computer-readable medium may include all computer storage media. The computer storage medium includes both volatile and non-volatile, removable and non-removable media implemented by any method or technique for storing information such as computer-readable instructions, data structures, program modules, or other data.

[0129] A method for providing an automated SSH terminal solution including a security bridge between a remote AI agent and a local resource according to an embodiment of the present invention described above may be executed by an application installed by default on a terminal (which may include a program included in a platform or operating system installed by default on the terminal), or by an application (i.e., a program) directly installed by a user on a master terminal through an application providing server, such as an application store server, an application, or a web server related to the service. In this sense, the method for providing an automated SSH terminal solution including a security bridge between a remote AI agent and a local resource according to an embodiment of the present invention described above may be implemented as an application (i.e., a program) that is installed by default on the terminal or directly installed by a user, and may be recorded on a computer-readable recording medium such as a terminal.

[0130] The foregoing description of the present invention is for illustrative purposes only, and those skilled in the art will understand that other specific forms can be easily modified without altering the technical spirit or essential features of the present invention. Therefore, the embodiments described above should be understood as illustrative in all respects and not restrictive. For example, each component described as a single unit may be implemented in a distributed manner, and components described as distributed may likewise be implemented in a combined form.

[0131] The scope of the present invention is defined by the claims set forth below rather than by the detailed description above, and all modifications or variations derived from the meaning and scope of the claims and equivalent concepts thereof should be interpreted as being included within the scope of the present invention.

Claims

Claim 1 Development server running the AI ​​agent; A user terminal comprising: an operating unit that runs a core engine connecting an AI agent of the development server and an OS (Operating System); an SSH connection unit that creates an SSH (Secure Shell) session and connects to the development server when a connection to the development server is requested; an MCP execution unit that executes at least one pre-configured MCP (Model Context Protocol) server; a relay connection unit that executes a relay server to connect the at least one MCP server to the development server; an integration unit that integrates the at least one MCP server; an access configuration unit that configures the AI ​​agent of the development server to call the MCP tool of the MCP server by exposing the port of the relay server to the development server via SSH reverse forwarding; and a multi-file transfer unit that transmits the plurality of files to the development server by receiving a list of all file paths stored in the native clipboard through the native command system of a pre-established desktop framework to read the plurality of files copied from the Windows Explorer of the user terminal, and sequentially uploading the plurality of files to SFTP (Secure File Transfer Protocol) based on the list of all file paths. Automated SSH terminal system including a security bridge between a remote AI agent and local resources. Claim 2 An automated SSH terminal system including a security bridge between a remote AI agent and a local resource, wherein, in claim 1, the user terminal further comprises: a policy application unit that evaluates the request in a pre-established policy engine when a request from an AI agent of the development server is received; an output unit that outputs an approval request if the result of the evaluation of the request is user confirmation; and an execution decision unit that determines whether to execute the request of the AI ​​agent according to the input for the approval request. Claim 3 An automated SSH terminal system comprising a security bridge between a remote AI agent and a local resource, characterized in that, in claim 2, the request includes ScreenCapture, FileUpload, BrowserOpen, ClipboardRead, ClipboardWrite, and NotifyShow, and the evaluation of the request by the policy engine is one of Automatic Allow, Automatic Deny, and User Confirmation (Ask), and the approval request is provided as a one-time allow that allows only once; a session allow that automatically allows the same request during the same session; and a denial that denies the request, thereby receiving a selection of one of the inputs. Claim 4 An automated SSH terminal system including a security bridge between a remote AI agent and a local resource, characterized in that, in claim 1, the user terminal further comprises an automatic port detection unit that analyzes the standard output stream of the virtual terminal (pseudo terminal) of the SSH in real time to automatically recognize the port of the development server, outputs to the screen a request for port forwarding for the port to the user, and, when the port forwarding is approved, sets the port forwarding and runs a browser. Claim 5 delete Claim 6 An automated SSH terminal system including a security bridge between a remote AI agent and a local resource, characterized in that, in the first aspect, the user terminal receives a screen capture from the AI ​​agent when the AI ​​agent needs to check the screen of the user terminal, evaluates the screen capture in a pre-established policy engine, outputs an approval request if the result of the evaluation of the screen capture is user confirmation, executes the screen capture if the input for the approval request is allowed, and transmits the screen-captured image to the AI ​​agent by encoding it and uploading it via SFTP (Secure File Transfer Protocol). Claim 7 An automated SSH terminal system comprising a security bridge between a remote AI agent and a local resource, wherein, in claim 1, the core engine is designed as a headless session engine and operates independently, separated from the User Interface (UI) application running on the user terminal.

Images