connectivity and other docs

README.md

@@ -12,6 +12,7 @@
 [Installation](./docs/installation.md) •
 [Development](./docs/development.md) •
 [Extensibility](./docs/extensibility.md) •
+[Connectivity](./docs/connectivity.md) •
 [How to update](./docs/installation.md#how-to-update-agent-zero) •
 [Documentation](./docs/README.md) •
 [Usage](./docs/usage.md)
@@ -158,6 +159,9 @@ docker run -p 50001:80 agent0ai/agent-zero
 |-------|-------------|
 | [Installation](./docs/installation.md) | Installation, setup and configuration |
 | [Usage](./docs/usage.md) | Basic and advanced usage |
+| [Development](./docs/development.md) | Development and customization |
+| [Extensibility](./docs/extensibility.md) | Extending Agent Zero |
+| [Connectivity](./docs/connectivity.md) | External API endpoints, MCP server connections, A2A protocol |
 | [Architecture](./docs/architecture.md) | System design and components |
 | [Contributing](./docs/contribution.md) | How to contribute |
 | [Troubleshooting](./docs/troubleshooting.md) | Common issues and their solutions |
@@ -165,6 +169,34 @@ docker run -p 50001:80 agent0ai/agent-zero
 
 ## 🎯 Changelog
 
+### v0.9.4 - Connectivity, UI
+- External API endpoints
+- Streamable HTTP MCP A0 server
+- A2A (Agent to Agent) protocol - server+client
+- New notifications system
+- New local terminal interface for stability
+- Rate limiter integration to models
+- Smarter autoscrolling in UI
+- Action buttons in messages
+- Multiple API keys support
+- Download streaming
+- Tunnel URL QR code
+- Internal fixes and optimizations
+
+### v0.9.3 - Subordinates, memory, providers Latest
+[Release video](https://www.youtube.com/watch?v=-LfejFWL34k)
+- Faster startup/restart
+- Subordinate agents can have dedicated prompts, tools and system extensions
+- Streamable HTTP MCP server support
+- Memory loading enhanced by AI filter
+- Memory AI consolidation when saving memories
+- Auto memory system configuration in settings
+- LLM providers available are set by providers.yaml configuration file
+- Venice.ai LLM provider supported
+- Initial agent message for user + as example for LLM
+- Docker build support for local images
+- File browser fix
+
 
 ### v0.9.2 - Kokoro TTS, Attachments
 [Release video](https://www.youtube.com/watch?v=sPot_CAX62I)
@@ -174,7 +206,6 @@ docker run -p 50001:80 agent0ai/agent-zero
 - Minor updates: log truncation, hyperlink targets, component examples, api cleanup
 
 
-
 ### v0.9.1 - LiteLLM, UI improvements
 [Release video](https://youtu.be/crwr0M4Spcg)
 - Langchain replaced with LiteLLM

docs/README.md

@@ -6,6 +6,7 @@ To begin with Agent Zero, follow the links below for detailed guides on various
 - **[Usage Guide](usage.md):** Explore GUI features and usage scenarios.
 - **[Development](development.md):** Set up a development environment for Agent Zero.
 - **[Extensibility](extensibility.md):** Learn how to create custom extensions for Agent Zero.
+- **[Connectivity](connectivity.md):** Learn how to connect to Agent Zero from other applications.
 - **[Architecture Overview](architecture.md):** Understand the internal workings of the framework.
 - **[Contributing](contribution.md):** Learn how to contribute to the Agent Zero project.
 - **[Troubleshooting and FAQ](troubleshooting.md):** Find answers to common issues and questions.

docs/connectivity.md

@@ -0,0 +1,585 @@
+# Agent Zero Connectivity Guide
+
+This guide covers the different ways to connect to Agent Zero from external applications, including using the External API, connecting as an MCP client, and enabling agent-to-agent communication.
+
+**Note:** You can find your specific URLs and API tokens in your Agent Zero instance under `Settings > External Services`.
+
+### API Token Information
+
+The API token is automatically generated from your username and password. This same token is used for External API endpoints, MCP server connections, and A2A communication. The token will change if you update your credentials.
+
+---
+
+## External API Endpoints
+
+Agent Zero provides external API endpoints for integration with other applications. These endpoints use API key authentication and support text messages and file attachments.
+
+### `POST /api_message`
+
+Send messages to Agent Zero and receive responses. Supports text messages, file attachments, and conversation continuity.
+
+### API Reference
+
+**Parameters:**
+*   `context_id` (string, optional): Existing chat context ID
+*   `message` (string, required): The message to send
+*   `attachments` (array, optional): Array of `{filename, base64}` objects
+*   `lifetime_hours` (number, optional): Chat lifetime in hours (default: 24)
+
+**Headers:**
+*   `X-API-KEY` (required)
+*   `Content-Type: application/json`
+
+### JavaScript Examples
+
+#### Basic Usage Example
+
+```javascript
+// Basic message example
+async function sendMessage() {
+    try {
+        const response = await fetch('YOUR_AGENT_ZERO_URL/api_message', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-API-KEY': 'YOUR_API_KEY'
+            },
+            body: JSON.stringify({
+                message: "Hello, how can you help me?",
+                lifetime_hours: 24
+            })
+        });
+
+        const data = await response.json();
+
+        if (response.ok) {
+            console.log('✅ Success!');
+            console.log('Response:', data.response);
+            console.log('Context ID:', data.context_id);
+            return data;
+        } else {
+            console.error('❌ Error:', data.error);
+            return null;
+        }
+    } catch (error) {
+        console.error('❌ Request failed:', error);
+        return null;
+    }
+}
+
+// Call the function
+sendMessage().then(result => {
+    if (result) {
+        console.log('Message sent successfully!');
+    }
+});
+```
+
+#### Conversation Continuation Example
+
+```javascript
+// Continue conversation example
+async function continueConversation(contextId) {
+    try {
+        const response = await fetch('YOUR_AGENT_ZERO_URL/api_message', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-API-KEY': 'YOUR_API_KEY'
+            },
+            body: JSON.stringify({
+                context_id: contextId,
+                message: "Can you tell me more about that?",
+                lifetime_hours: 24
+            })
+        });
+
+        const data = await response.json();
+
+        if (response.ok) {
+            console.log('✅ Continuation Success!');
+            console.log('Response:', data.response);
+            return data;
+        } else {
+            console.error('❌ Error:', data.error);
+            return null;
+        }
+    } catch (error) {
+        console.error('❌ Request failed:', error);
+        return null;
+    }
+}
+
+// Example: First send a message, then continue the conversation
+async function fullConversationExample() {
+    const firstResult = await sendMessage();
+    if (firstResult && firstResult.context_id) {
+        await continueConversation(firstResult.context_id);
+    }
+}
+
+fullConversationExample();
+```
+
+#### File Attachment Example
+
+```javascript
+// File attachment example
+async function sendWithAttachment() {
+    try {
+        // Example with text content (convert to base64)
+        const textContent = "Hello World from attachment!";
+        const base64Content = btoa(textContent);
+
+        const response = await fetch('YOUR_AGENT_ZERO_URL/api_message', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-API-KEY': 'YOUR_API_KEY'
+            },
+            body: JSON.stringify({
+                message: "Please analyze this file:",
+                attachments: [
+                    {
+                        filename: "document.txt",
+                        base64: base64Content
+                    }
+                ],
+                lifetime_hours: 12
+            })
+        });
+
+        const data = await response.json();
+
+        if (response.ok) {
+            console.log('✅ File sent successfully!');
+            console.log('Response:', data.response);
+            return data;
+        } else {
+            console.error('❌ Error:', data.error);
+            return null;
+        }
+    } catch (error) {
+        console.error('❌ Request failed:', error);
+        return null;
+    }
+}
+
+// Call the function
+sendWithAttachment();
+```
+
+---
+
+## `GET/POST /api_log_get`
+
+Retrieve log data by context ID, limited to a specified number of entries from the newest.
+
+### API Reference
+
+**Parameters:**
+*   `context_id` (string, required): Context ID to get logs from
+*   `length` (integer, optional): Number of log items to return from newest (default: 100)
+
+**Headers:**
+*   `X-API-KEY` (required)
+*   `Content-Type: application/json` (for POST)
+
+### JavaScript Examples
+
+#### GET Request Example
+
+```javascript
+// Get logs using GET request
+async function getLogsGET(contextId, length = 50) {
+    try {
+        const params = new URLSearchParams({
+            context_id: contextId,
+            length: length.toString()
+        });
+
+        const response = await fetch('YOUR_AGENT_ZERO_URL/api_log_get?' + params, {
+            method: 'GET',
+            headers: {
+                'X-API-KEY': 'YOUR_API_KEY'
+            }
+        });
+
+        const data = await response.json();
+
+        if (response.ok) {
+            console.log('✅ Logs retrieved successfully!');
+            console.log('Total items:', data.log.total_items);
+            console.log('Returned items:', data.log.returned_items);
+            console.log('Log items:', data.log.items);
+            return data;
+        } else {
+            console.error('❌ Error:', data.error);
+            return null;
+        }
+    } catch (error) {
+        console.error('❌ Request failed:', error);
+        return null;
+    }
+}
+
+// Example usage
+getLogsGET('ctx_abc123', 20);
+```
+
+#### POST Request Example
+
+```javascript
+// Get logs using POST request
+async function getLogsPOST(contextId, length = 50) {
+    try {
+        const response = await fetch('YOUR_AGENT_ZERO_URL/api_log_get', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-API-KEY': 'YOUR_API_KEY'
+            },
+            body: JSON.stringify({
+                context_id: contextId,
+                length: length
+            })
+        });
+
+        const data = await response.json();
+
+        if (response.ok) {
+            console.log('✅ Logs retrieved successfully!');
+            console.log('Context ID:', data.context_id);
+            console.log('Log GUID:', data.log.guid);
+            console.log('Total items:', data.log.total_items);
+            console.log('Returned items:', data.log.returned_items);
+            console.log('Start position:', data.log.start_position);
+            console.log('Progress:', data.log.progress);
+            console.log('Log items:', data.log.items);
+            return data;
+        } else {
+            console.error('❌ Error:', data.error);
+            return null;
+        }
+    } catch (error) {
+        console.error('❌ Request failed:', error);
+        return null;
+    }
+}
+
+// Example usage - get latest 10 log entries
+getLogsPOST('ctx_abc123', 10);
+```
+
+---
+
+## `POST /api_terminate_chat`
+
+Terminate and remove a chat context to free up resources. Similar to the MCP `finish_chat` function.
+
+### API Reference
+
+**Parameters:**
+*   `context_id` (string, required): Context ID of the chat to terminate
+
+**Headers:**
+*   `X-API-KEY` (required)
+*   `Content-Type: application/json`
+
+### JavaScript Examples
+
+#### Basic Termination Examples
+
+```javascript
+// Basic terminate chat function
+async function terminateChat(contextId) {
+    try {
+        const response = await fetch('YOUR_AGENT_ZERO_URL/api_terminate_chat', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-API-KEY': 'YOUR_API_KEY'
+            },
+            body: JSON.stringify({
+                context_id: contextId
+            })
+        });
+
+        const data = await response.json();
+
+        if (response.ok) {
+            console.log('✅ Chat deleted successfully!');
+            console.log('Message:', data.message);
+            return data;
+        } else {
+            console.error('❌ Error:', data.error);
+            return null;
+        }
+    } catch (error) {
+        console.error('❌ Request failed:', error);
+        return null;
+    }
+}
+
+// Example 1: Terminate a specific chat
+terminateChat('ctx_abc123');
+
+// Example 2: Complete workflow - send message, then terminate
+async function simpleWorkflow() {
+    // Send a message
+    const result = await sendMessage();
+
+    if (result && result.context_id) {
+        console.log('Chat created:', result.context_id);
+
+        // Do some work with the chat...
+        // await continueConversation(result.context_id);
+
+        // Clean up when done
+        await terminateChat(result.context_id);
+        console.log('Chat cleaned up');
+    }
+}
+
+// Run the workflow
+simpleWorkflow();
+```
+
+---
+
+## `POST /api_reset_chat`
+
+Reset a chat context to clear conversation history while keeping the `context_id` alive for continued use.
+
+### API Reference
+
+**Parameters:**
+*   `context_id` (string, required): Context ID of the chat to reset
+
+**Headers:**
+*   `X-API-KEY` (required)
+*   `Content-Type: application/json`
+
+### JavaScript Examples
+
+#### Basic Reset Examples
+
+```javascript
+// Basic reset chat function
+async function resetChat(contextId) {
+    try {
+        const response = await fetch('YOUR_AGENT_ZERO_URL/api_reset_chat', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-API-KEY': 'YOUR_API_KEY'
+            },
+            body: JSON.stringify({
+                context_id: contextId
+            })
+        });
+
+        const data = await response.json();
+
+        if (response.ok) {
+            console.log('✅ Chat reset successfully!');
+            console.log('Message:', data.message);
+            console.log('Context ID:', data.context_id);
+            return data;
+        } else {
+            console.error('❌ Error:', data.error);
+            return null;
+        }
+    } catch (error) {
+        console.error('❌ Request failed:', error);
+        return null;
+    }
+}
+
+// Example 1: Reset a specific chat
+resetChat('ctx_abc123');
+
+// Example 2: Reset and continue conversation
+async function resetAndContinue() {
+    const contextId = 'ctx_abc123';
+
+    // Reset the chat to clear history
+    const resetResult = await resetChat(contextId);
+
+    if (resetResult) {
+        console.log('Chat reset, starting fresh conversation...');
+
+        // Continue with same context_id but fresh history
+        const response = await fetch('YOUR_AGENT_ZERO_URL/api_message', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-API-KEY': 'YOUR_API_KEY'
+            },
+            body: JSON.stringify({
+                context_id: contextId,  // Same context ID
+                message: "Hello, this is a fresh start!",
+                lifetime_hours: 24
+            })
+        });
+
+        const data = await response.json();
+        console.log('New conversation started:', data.response);
+    }
+}
+
+// Run the example
+resetAndContinue();
+```
+
+---
+
+## `POST /api_files_get`
+
+Retrieve file contents by paths, returning files as base64 encoded data. Useful for retrieving uploaded attachments.
+
+### API Reference
+
+**Parameters:**
+*   `paths` (array, required): Array of file paths to retrieve (e.g., `["/a0/tmp/uploads/file.txt"]`)
+
+**Headers:**
+*   `X-API-KEY` (required)
+*   `Content-Type: application/json`
+
+### JavaScript Examples
+
+#### File Retrieval Examples
+
+```javascript
+// Basic file retrieval
+async function getFiles(filePaths) {
+    try {
+        const response = await fetch('YOUR_AGENT_ZERO_URL/api_files_get', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-API-KEY': 'YOUR_API_KEY'
+            },
+            body: JSON.stringify({
+                paths: filePaths
+            })
+        });
+
+        const data = await response.json();
+
+        if (response.ok) {
+            console.log('✅ Files retrieved successfully!');
+            console.log('Retrieved files:', Object.keys(data));
+
+            // Convert base64 back to text for display
+            for (const [filename, base64Content] of Object.entries(data)) {
+                try {
+                    const textContent = atob(base64Content);
+                    console.log(`${filename}: ${textContent.substring(0, 100)}...`);
+                } catch (e) {
+                    console.log(`${filename}: Binary file (${base64Content.length} chars)`);
+                }
+            }
+
+            return data;
+        } else {
+            console.error('❌ Error:', data.error);
+            return null;
+        }
+    } catch (error) {
+        console.error('❌ Request failed:', error);
+        return null;
+    }
+}
+
+// Example 1: Get specific files
+const filePaths = [
+    "/a0/tmp/uploads/document.txt",
+    "/a0/tmp/uploads/data.json"
+];
+getFiles(filePaths);
+
+// Example 2: Complete attachment workflow
+async function attachmentWorkflow() {
+    // Step 1: Send message with attachments
+    const messageResponse = await fetch('YOUR_AGENT_ZERO_URL/api_message', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'X-API-KEY': 'YOUR_API_KEY'
+        },
+        body: JSON.stringify({
+            message: "Please analyze this file",
+            attachments: [{
+                filename: "test.txt",
+                base64: btoa("Hello, this is test content!")
+            }],
+            lifetime_hours: 1
+        })
+    });
+
+    if (messageResponse.ok) {
+        console.log('Message sent with attachment');
+
+        // Step 2: Retrieve the uploaded file
+        const retrievedFiles = await getFiles(["/a0/tmp/uploads/test.txt"]);
+
+        if (retrievedFiles && retrievedFiles["test.txt"]) {
+            const originalContent = atob(retrievedFiles["test.txt"]);
+            console.log('Retrieved content:', originalContent);
+        }
+    }
+}
+
+// Run the complete workflow
+attachmentWorkflow();
+```
+
+---
+
+## MCP Server Connectivity
+
+Agent Zero includes an MCP Server that allows other MCP-compatible clients to connect to it. The server runs on the same URL and port as the Web UI.
+
+It provides two endpoint types:
+- **SSE (`/mcp/sse`):** For clients that support Server-Sent Events.
+- **Streamable HTTP (`/mcp/http/`):** For clients that use streamable HTTP requests.
+
+### Example MCP Server Configuration
+
+Below is an example of a `mcp.json` configuration file that a client could use to connect to the Agent Zero MCP server. 
+
+**Note:** You can find your personalized connection URLs under `Settings > MCP Server > MCP Server`.
+
+```json
+{
+    "mcpServers":
+    {
+        "agent-zero": {
+            "type": "sse",
+            "url": "YOUR_AGENT_ZERO_URL/mcp/t-YOUR_API_TOKEN/sse"
+        },
+        "agent-zero-http": {
+            "type": "streamable-http",
+            "url": "YOUR_AGENT_ZERO_URL/mcp/t-YOUR_API_TOKEN/http/"
+        }
+    }
+}
+```
+
+---
+
+## A2A (Agent-to-Agent) Connectivity
+
+Agent Zero's A2A Server enables communication with other agents using the FastA2A protocol. Other agents can connect to your instance using the connection URL.
+
+### A2A Connection URL
+
+To connect another agent to your Agent Zero instance, use the following URL format. 
+
+**Note:** You can find your specific A2A connection URL under `Settings > External Services > A2A Connection`.
+
+```
+YOUR_AGENT_ZERO_URL/a2a/t-YOUR_API_TOKEN
+```

docs/development.md

@@ -1,6 +1,11 @@
 # Development manual for Agent Zero
 This guide will show you how to setup a local development environment for Agent Zero in a VS Code compatible IDE, including proper debugger.
 
+
+[![Tutorial video](./res/devguide_vid.png)](https://www.youtube.com/watch?v=KE39P4qBjDk)
+
+
+
 > [!WARNING]
 > This guide is for developers and contributors. It assumes you have a basic understanding of how to use Git/GitHub, Docker, IDEs and Python.
 

tests/tty_test.py

@@ -1,266 +0,0 @@
-"""
-tty_spawn.py – drive any console program through a real TTY
-cross-platform (Windows via pywinpty, POSIX via pty).
-
-API (async):
-    term = TTYSpawn(cmd, *, cwd=None, env=None, encoding="utf-8")
-    await term.start()             # launch child
-    chunk = await term.read(timeout=1.0)     # None on timeout
-    await term.send("data")        # raw bytes
-    await term.sendline("text")    # adds '\n'
-    await term.wait()              # exit code
-    term.kill()                    # abort
-"""
-# ──────────────────  NO ORIGINAL LINES REMOVED – ONLY APPENDED CODE  ──────────────────
-
-import asyncio, os, sys, platform, errno
-
-_IS_WIN = platform.system() == "Windows"
-if _IS_WIN:
-    import winpty        # pip install pywinpty
-    import msvcrt
-
-
-#  Make stdin / stdout tolerant to broken UTF-8 so input() never aborts
-try:
-    # Python 3.7+ has reconfigure()
-    sys.stdin .reconfigure(errors="replace")
-    sys.stdout.reconfigure(errors="replace")
-except AttributeError:
-    # Older Pythons: wrap them manually
-    import io
-    sys.stdin  = io.TextIOWrapper(sys.stdin.buffer,
-                                  encoding=sys.stdin.encoding or "utf-8",
-                                  errors="replace",
-                                  line_buffering=True)
-    sys.stdout = io.TextIOWrapper(sys.stdout.buffer,
-                                  encoding=sys.stdout.encoding or "utf-8",
-                                  errors="replace",
-                                  line_buffering=True)
-#  ─────────────────────────────────────────────────────────────────────
-
-
-# ──────────────────────────── PUBLIC CLASS ────────────────────────────
-
-class TTYSpawn:
-    def __init__(self, cmd, *, cwd=None, env=None,
-                 encoding="utf-8", echo=True):          # ← NEW kw-arg `echo`
-        self.cmd = cmd if isinstance(cmd, str) else " ".join(cmd)
-        self.cwd = cwd
-        self.env = env or os.environ.copy()
-        self.encoding = encoding
-        self.echo = echo                                # ← store preference
-        self._proc = None
-        self._buf = asyncio.Queue()
-
-    # ── user-facing coroutines ────────────────────────────────────────
-    async def start(self):
-        if _IS_WIN:
-            self._proc = await _spawn_winpty(
-                self.cmd, self.cwd, self.env, self.echo)     # ← pass echo
-        else:
-            self._proc = await _spawn_posix_pty(
-                self.cmd, self.cwd, self.env, self.echo)     # ← pass echo
-        asyncio.create_task(self._pump_stdout())
-
-    async def read(self, timeout=None):
-        # Return any decoded text the child produced, or None on timeout
-        try:
-            return await asyncio.wait_for(self._buf.get(), timeout)
-        except asyncio.TimeoutError:
-            return None
-
-    # backward-compat alias:
-    readline = read
-
-    async def send(self, data: str | bytes):
-        if isinstance(data, str):
-            data = data.encode(self.encoding)
-        self._proc.stdin.write(data)
-        await self._proc.stdin.drain()
-
-    async def sendline(self, line: str):
-        await self.send(line + "\n")
-
-    async def wait(self):
-        return await self._proc.wait()
-
-    def kill(self):
-        self._proc.kill()
-
-    async def read_until_idle(self, idle_timeout, total_timeout):
-        # Collect child output using iter_until_idle to avoid duplicate logic
-        return "".join([chunk async for chunk in self.iter_until_idle(idle_timeout, total_timeout)])
-
-    async def iter_until_idle(self, idle_timeout, total_timeout):
-        # Yield each chunk as soon as it arrives until idle or total timeout
-        import time
-        start = time.monotonic()
-        while True:
-            if time.monotonic() - start > total_timeout:
-                break
-            chunk = await self.read(timeout=idle_timeout)
-            if chunk is None:
-                break
-            yield chunk
-
-    # ── internal: stream raw output into the queue ────────────────────
-    async def _pump_stdout(self):
-        reader = self._proc.stdout
-        while True:
-            chunk = await reader.read(4096)      # grab whatever is ready
-            if not chunk:
-                break
-            self._buf.put_nowait(chunk.decode(self.encoding, "replace"))
-
-# ──────────────────────────── POSIX IMPLEMENTATION ────────────────────
-
-async def _spawn_posix_pty(cmd, cwd, env, echo):
-    import pty, asyncio, os, termios
-    master, slave = pty.openpty()
-
-    # ── Disable ECHO on the slave side if requested ──
-    if not echo:
-        attrs = termios.tcgetattr(slave)
-        attrs[3] &= ~termios.ECHO          # lflag
-        termios.tcsetattr(slave, termios.TCSANOW, attrs)
-
-    proc = await asyncio.create_subprocess_shell(
-        cmd,
-        stdin=slave,
-        stdout=slave,
-        stderr=slave,
-        cwd=cwd,
-        env=env,
-        close_fds=True,
-    )
-    os.close(slave)
-
-    loop = asyncio.get_running_loop()
-    reader = asyncio.StreamReader()
-
-    def _on_data():
-        try:
-            data = os.read(master, 1 << 16)
-        except OSError as e:
-            if e.errno != errno.EIO:  # EIO == EOF on some systems
-                raise
-            data = b""
-        if data:
-            reader.feed_data(data)
-        else:
-            reader.feed_eof()
-            loop.remove_reader(master)
-
-    loop.add_reader(master, _on_data)
-
-    class _Stdin:
-        def write(self, d): os.write(master, d)
-        async def drain(self): await asyncio.sleep(0)
-
-    proc.stdin = _Stdin()
-    proc.stdout = reader
-    return proc
-
-# ──────────────────────────── WINDOWS IMPLEMENTATION ──────────────────
-
-async def _spawn_winpty(cmd, cwd, env, echo):
-    # A quick way to silence command echo in cmd.exe is /Q (quiet)
-    if not echo and cmd.strip().lower().startswith("cmd") and "/q" not in cmd.lower():
-        cmd = cmd.replace("cmd.exe", "cmd.exe /Q")
-
-    cols, rows = 80, 25
-    pty = winpty.PTY(cols, rows)
-    child = pty.spawn(cmd, cwd=cwd or os.getcwd(), env=env)
-
-    master_r_fd = msvcrt.open_osfhandle(child.conout_pipe, os.O_RDONLY)
-    master_w_fd = msvcrt.open_osfhandle(child.conin_pipe, 0)
-
-    loop = asyncio.get_running_loop()
-    reader = asyncio.StreamReader()
-
-    def _on_data():
-        try:
-            data = os.read(master_r_fd, 1 << 16)
-        except OSError:
-            data = b""
-        if data:
-            reader.feed_data(data)
-        else:
-            reader.feed_eof()
-            loop.remove_reader(master_r_fd)
-
-    loop.add_reader(master_r_fd, _on_data)
-
-    class _Stdin:
-        def write(self, d): os.write(master_w_fd, d)
-        async def drain(self): await asyncio.sleep(0)
-
-    class _Proc(asyncio.subprocess.Process):
-        def __init__(self):
-            self.stdin = _Stdin()
-            self.stdout = reader
-            self.pid = child.pid
-        async def wait(self):
-            while child.isalive():
-                await asyncio.sleep(0.2)
-            return 0
-        def kill(self):
-            child.kill()
-
-    return _Proc()
-
-# ───────────────────────── INTERACTIVE DRIVER ─────────────────────────
-
-async def interactive_shell():
-    shell_cmd, prompt_hint = (
-        ("cmd.exe", "$") if _IS_WIN else ("/bin/bash", "$")
-    )
-
-    # echo=False → suppress the shell’s own echo of commands
-    term = TTYSpawn(shell_cmd, echo=False)
-    await term.start()
-
-    timeout = 1.0
-
-    print(f"Connected to {shell_cmd}.")
-    print("Type commands for the shell.")
-    print("• t=<seconds>  → change idle timeout")
-    print("• exit         → quit helper\n")
-
-    await term.sendline(" ")
-    print(await term.read_until_idle(timeout, timeout), end="", flush=True)
-
-    while True:
-        try:
-            user = input(f"(timeout={timeout}) {prompt_hint} ")
-        except (EOFError, KeyboardInterrupt):
-            print("\nLeaving…")
-            break
-
-        if user.lower() == "/exit":
-            break
-        if user.startswith("/t="):
-            try:
-                timeout = float(user.split("=", 1)[1])
-                print(f"[helper] idle timeout set to {timeout}s")
-            except ValueError:
-                print("[helper] invalid number")
-            continue
-
-        idle_timeout = timeout
-        total_timeout = 10 * idle_timeout
-        if user == "":
-            # Just read output, do not send empty line
-            async for chunk in term.iter_until_idle(idle_timeout, total_timeout):
-                print(chunk, end="", flush=True)
-        else:
-            await term.sendline(user)
-            async for chunk in term.iter_until_idle(idle_timeout, total_timeout):
-                print(chunk, end="", flush=True)
-
-    await term.sendline("exit")
-    await term.wait()
-
-if __name__ == "__main__":
-    asyncio.run(interactive_shell())

webui/index.html

@@ -619,7 +619,7 @@
                                                 </template>
 
 
-                                                                                                <!-- Password field -->
+                                                <!-- Password field -->
                                                 <template x-if="field.type === 'password'">
                                                     <input type="password" :class="field.classes" :value="field.value"
                                                         :readonly="field.readonly === true"

webui/vendor/ace-min/ext-beautify [conflicted].js

@@ -0,0 +1,8 @@
+define("ace/ext/beautify",["require","exports","module","ace/token_iterator"],function(e,t,n){"use strict";function i(e,t){return e.type.lastIndexOf(t+".xml")>-1}var r=e("../token_iterator").TokenIterator;t.singletonTags=["area","base","br","col","command","embed","hr","html","img","input","keygen","link","meta","param","source","track","wbr"],t.blockTags=["article","aside","blockquote","body","div","dl","fieldset","footer","form","head","header","html","nav","ol","p","script","section","style","table","tbody","tfoot","thead","ul"],t.formatOptions={lineBreaksAfterCommasInCurlyBlock:!0},t.beautify=function(e){var n=new r(e,0,0),s=n.getCurrentToken(),o=e.getTabString(),u=t.singletonTags,a=t.blockTags,f=t.formatOptions||{},l,c=!1,h=!1,p=!1,d="",v="",m="",g=0,y=0,b=0,w=0,E=0,S=0,x=0,T,N=0,C=0,k=[],L=!1,A,O=!1,M=!1,_=!1,D=!1,P={0:0},H=[],B=!1,j=function(){l&&l.value&&l.type!=="string.regexp"&&(l.value=l.value.replace(/^\s*/,""))},F=function(){var e=d.length-1;for(;;){if(e==0)break;if(d[e]!==" ")break;e-=1}d=d.slice(0,e+1)},I=function(){d=d.trimRight(),c=!1};while(s!==null){N=n.getCurrentTokenRow(),k=n.$rowTokens,l=n.stepForward();if(typeof s!="undefined"){v=s.value,E=0,_=m==="style"||e.$modeId==="ace/mode/css",i(s,"tag-open")?(M=!0,l&&(D=a.indexOf(l.value)!==-1),v==="</"&&(D&&!c&&C<1&&C++,_&&(C=1),E=1,D=!1)):i(s,"tag-close")?M=!1:i(s,"comment.start")?D=!0:i(s,"comment.end")&&(D=!1),!M&&!C&&s.type==="paren.rparen"&&s.value.substr(0,1)==="}"&&C++,N!==T&&(C=N,T&&(C-=T));if(C){I();for(;C>0;C--)d+="\n";c=!0,!i(s,"comment")&&!s.type.match(/^(comment|string)$/)&&(v=v.trimLeft())}if(v){s.type==="keyword"&&v.match(/^(if|else|elseif|for|foreach|while|switch)$/)?(H[g]=v,j(),p=!0,v.match(/^(else|elseif)$/)&&d.match(/\}[\s]*$/)&&(I(),h=!0)):s.type==="paren.lparen"?(j(),v.substr(-1)==="{"&&(p=!0,O=!1,M||(C=1)),v.substr(0,1)==="{"&&(h=!0,d.substr(-1)!=="["&&d.trimRight().substr(-1)==="["?(I(),h=!1):d.trimRight().substr(-1)===")"?I():F())):s.type==="paren.rparen"?(E=1,v.substr(0,1)==="}"&&(H[g-1]==="case"&&E++,d.trimRight().substr(-1)==="{"?I():(h=!0,_&&(C+=2))),v.substr(0,1)==="]"&&d.substr(-1)!=="}"&&d.trimRight().substr(-1)==="}"&&(h=!1,w++,I()),v.substr(0,1)===")"&&d.substr(-1)!=="("&&d.trimRight().substr(-1)==="("&&(h=!1,w++,I()),F()):s.type!=="keyword.operator"&&s.type!=="keyword"||!v.match(/^(=|==|===|!=|!==|&&|\|\||and|or|xor|\+=|.=|>|>=|<|<=|=>)$/)?s.type==="punctuation.operator"&&v===";"?(I(),j(),p=!0,_&&C++):s.type==="punctuation.operator"&&v.match(/^(:|,)$/)?(I(),j(),v.match(/^(,)$/)&&x>0&&S===0&&f.lineBreaksAfterCommasInCurlyBlock?C++:(p=!0,c=!1)):s.type==="support.php_tag"&&v==="?>"&&!c?(I(),h=!0):i(s,"attribute-name")&&d.substr(-1).match(/^\s$/)?h=!0:i(s,"attribute-equals")?(F(),j()):i(s,"tag-close")?(F(),v==="/>"&&(h=!0)):s.type==="keyword"&&v.match(/^(case|default)$/)&&B&&(E=1):(I(),j(),h=!0,p=!0);if(c&&(!s.type.match(/^(comment)$/)||!!v.substr(0,1).match(/^[/#]$/))&&(!s.type.match(/^(string)$/)||!!v.substr(0,1).match(/^['"@]$/))){w=b;if(g>y){w++;for(A=g;A>y;A--)P[A]=w}else g<y&&(w=P[g]);y=g,b=w,E&&(w-=E),O&&!S&&(w++,O=!1);for(A=0;A<w;A++)d+=o}s.type==="keyword"&&v.match(/^(case|default)$/)?B===!1&&(H[g]=v,g++,B=!0):s.type==="keyword"&&v.match(/^(break)$/)&&H[g-1]&&H[g-1].match(/^(case|default)$/)&&(g--,B=!1),s.type==="paren.lparen"&&(S+=(v.match(/\(/g)||[]).length,x+=(v.match(/\{/g)||[]).length,g+=v.length),s.type==="keyword"&&v.match(/^(if|else|elseif|for|while)$/)?(O=!0,S=0):!S&&v.trim()&&s.type!=="comment"&&(O=!1);if(s.type==="paren.rparen"){S-=(v.match(/\)/g)||[]).length,x-=(v.match(/\}/g)||[]).length;for(A=0;A<v.length;A++)g--,v.substr(A,1)==="}"&&H[g]==="case"&&g--}s.type=="text"&&(v=v.replace(/\s+$/," ")),h&&!c&&(F(),d.substr(-1)!=="\n"&&(d+=" ")),d+=v,p&&(d+=" "),c=!1,h=!1,p=!1;if(i(s,"tag-close")&&(D||a.indexOf(m)!==-1)||i(s,"doctype")&&v===">")D&&l&&l.value==="</"?C=-1:C=1;l&&u.indexOf(l.value)===-1&&(i(s,"tag-open")&&v==="</"?g--:i(s,"tag-open")&&v==="<"?g++:i(s,"tag-close")&&v==="/>"&&g--),i(s,"tag-name")&&(m=v),T=N}}s=l}d=d.trim(),e.doc.setValue(d)},t.commands=[{name:"beautify",description:"Format selection (Beautify)",exec:function(e){t.beautify(e.session)},bindKey:"Ctrl-Shift-B"}]});                (function() {
+                    window.require(["ace/ext/beautify"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+