pty-auto 0.3.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jens
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,515 @@
+# pty-auto
+
+A plugin for [OpenCode](https://opencode.ai) that provides interactive PTY (pseudo-terminal) management with mandatory spawn timeouts and bash-independent tool calls, enabling the AI agent to run background processes, send interactive input, and read output on demand.
+
+## Why?
+
+OpenCode's built-in `bash` tool runs commands synchronously—the agent waits for completion. This works for quick commands, but not for:
+
+- **Dev servers** (`npm run dev`, `cargo watch`)
+- **Watch modes** (`npm test -- --watch`)
+- **Long-running processes** (database servers, tunnels)
+- **Interactive programs** (REPLs, prompts)
+
+This plugin gives the agent full control over multiple terminal sessions, like tabs in a terminal app.
+
+## Features
+
+- **Background Execution**: Spawn processes that run independently
+- **Multiple Sessions**: Manage multiple PTYs simultaneously
+- **Interactive Input**: Send keystrokes, Ctrl+C, arrow keys, etc.
+- **Output Buffer**: Read output anytime with pagination (offset/limit)
+- **Pattern Filtering**: Search output using regex (like `grep`)
+- **Exit Notifications**: Get notified when processes finish (eliminates polling)
+- **Bash-Independent Tool Calls**: Uses PTY-specific tool calls instead of OpenCode's built-in `bash` permission path
+- **Session Lifecycle**: Sessions persist until explicitly killed
+- **Auto-cleanup**: PTYs are cleaned up when OpenCode sessions end
+- **Web UI**: Modern React-based interface for session management
+- **Real-time Streaming**: WebSocket-based live output updates
+
+## Setup
+
+Add the plugin to your [OpenCode config](https://opencode.ai/docs/config/):
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["pty-auto"]
+}
+```
+
+That's it. OpenCode will automatically install the plugin on next run.
+
+## Updating
+
+OpenCode automatically checks for and installs plugin updates on startup. You don't need to do anything manually!
+
+If you ever need to force a clean reinstall, you can clear the cache:
+
+```bash
+rm -rf ~/.cache/opencode/node_modules/pty-auto
+opencode
+```
+
+## Tools Provided
+
+| Tool        | Description                                                                 |
+| ----------- | --------------------------------------------------------------------------- |
+| `pty_spawn` | Create a new PTY session with a required `timeoutSeconds` budget (command, args, workdir, env, title, notifyOnExit) |
+| `pty_write` | Send input to a PTY (text, escape sequences like `\x03` for Ctrl+C)         |
+| `pty_read`  | Read output buffer with pagination and optional regex filtering             |
+| `pty_list`  | List all PTY sessions with status, PID, line count                          |
+| `pty_kill`  | Terminate a PTY, optionally cleanup the buffer                              |
+
+## Slash Commands
+
+This plugin provides slash commands that can be used in OpenCode chat:
+
+| Command                    | Description                                        |
+| -------------------------- | -------------------------------------------------- |
+| `/pty-open-background-spy` | Open the PTY web server interface in the browser   |
+| `/pty-show-server-url`     | Show the URL of the running PTY web server instance |
+
+## Web UI
+
+This plugin includes a modern React-based web interface for monitoring and interacting with PTY sessions.
+
+[![pty-auto Web UI Demo](https://img.youtube.com/vi/wPqmTPnzvVY/0.jpg)](https://youtu.be/wPqmTPnzvVY)
+
+If you instruct the coding agent to run something in background, you have to name it "session",
+i.e. "run xy as a background SESSION".
+If you name it "task" or "process" or anything else, the agent will sometimes run it as background subprocess using `&`.
+
+### Starting the Web UI
+
+1. Run opencode with the plugin.
+2. Run slash command `/pty-open-background-spy`.
+
+This will start the background sessions observer cockpit server and launch the browser with web UI.
+
+### Features
+
+- **Session List**: View all active PTY sessions with status indicators
+- **Real-time Output**: Live streaming of process output via WebSocket
+- **Interactive Input**: Send commands and input to running processes
+- **Session Management**: Kill sessions directly from the UI
+- **Connection Status**: Visual indicator of WebSocket connection status
+
+### REST API
+
+The web server provides a REST API for session management:
+
+| Method   | Endpoint                         | Description                                                                 |
+| -------- | -------------------------------- | --------------------------------------------------------------------------- |
+| `GET`    | `/api/sessions`                  | List all PTY sessions                                                       |
+| `POST`   | `/api/sessions`                  | Create a new PTY session                                                    |
+| `GET`    | `/api/sessions/:id`              | Get session details                                                         |
+| `POST`   | `/api/sessions/:id/input`        | Send input to a session                                                     |
+| `DELETE` | `/api/sessions/:id`              | Kill a session (without cleanup)                                            |
+| `DELETE` | `/api/sessions/:id/cleanup`      | Kill and cleanup a session                                                  |
+| `GET`    | `/api/sessions/:id/buffer/plain` | Get session output buffer (returns `{ plain: string, byteLength: number }`) |
+| `GET`    | `/api/sessions/:id/buffer/raw`   | Get session output buffer (raw data)                                        |
+| `DELETE` | `/api/sessions`                  | Clear all sessions                                                          |
+| `GET`    | `/health`                        | Server health check with metrics                                            |
+
+#### Session Creation
+
+```bash
+curl -X POST http://localhost:[PORT]/api/sessions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "command": "bash",
+    "args": ["-c", "echo hello && sleep 10"],
+    "description": "Test session",
+    "timeoutSeconds": 5
+  }'
+```
+
+Replace `[PORT]` with the actual port number shown in the server console output.
+
+#### WebSocket Streaming
+
+Connect to `/ws` for real-time updates:
+
+```javascript
+const ws = new WebSocket('ws://localhost:[PORT]/ws')
+
+ws.onmessage = (event) => {
+  const data = JSON.parse(event.data)
+  if (data.type === 'raw_data') {
+    console.log('New output:', data.rawData)
+  } else if (data.type === 'session_list') {
+    console.log('Session list:', data.sessions)
+  }
+}
+```
+
+Replace `[PORT]` with the actual port number shown in the browser when running the slash command output.
+
+### Development
+
+Future implementation will include:
+
+#### App
+
+- A startup script that runs the server (in the same process).
+- The startup script will run `bun vite` with an environment variable set to the server URL
+- The client will use this environment variable for WebSocket and HTTP requests
+
+This will ease the development on the client.
+
+## Usage Examples
+
+### Start a dev server
+
+```
+pty_spawn: command="npm", args=["run", "dev"], title="Dev Server", timeoutSeconds=600
+→ Returns: pty_a1b2c3d4
+```
+
+### Start a timed session
+
+```
+pty_spawn: command="npm", args=["run", "dev"], title="Dev Server", timeoutSeconds=600
+→ Returns: pty_a1b2c3d4
+```
+
+### Check server output
+
+```
+pty_read: id="pty_a1b2c3d4", limit=50
+→ Shows last 50 lines of output
+```
+
+### Filter for errors
+
+```
+pty_read: id="pty_a1b2c3d4", pattern="error|ERROR", ignoreCase=true
+→ Shows only lines matching the pattern
+```
+
+### Send Ctrl+C to stop
+
+```
+pty_write: id="pty_a1b2c3d4", data="\x03"
+→ Sends interrupt signal
+```
+
+### Kill and cleanup
+
+```
+pty_kill: id="pty_a1b2c3d4", cleanup=true
+→ Terminates process and frees buffer
+```
+
+### Run with exit notification
+
+```
+pty_spawn: command="npm", args=["run", "build"], title="Build", notifyOnExit=true, timeoutSeconds=900
+→ Returns: pty_a1b2c3d4
+```
+
+The AI agent will receive a notification when the build completes:
+
+```xml
+<pty_exited>
+ID: pty_a1b2c3d4
+Title: Build
+Exit Code: 0
+Output Lines: 42
+Last Line: Build completed successfully.
+</pty_exited>
+
+Use pty_read to check the full output.
+```
+
+This eliminates the need for polling—perfect for long-running processes like builds, tests, or deployment scripts. If the process fails (non-zero exit code), the notification will suggest using `pty_read` with the `pattern` parameter to search for errors.
+
+## Configuration
+
+### Environment Variables
+
+| Variable               | Default    | Description                                        |
+| ---------------------- | ---------- | -------------------------------------------------- |
+| `PTY_MAX_BUFFER_LINES` | `50000`    | Maximum lines to keep in output buffer per session |
+| `PTY_WEB_HOSTNAME`     | `::1`      | Hostname for the web server to bind to (IPv6 loopback by default) |
+| `PTY_WEB_PORT`         | `0` (random) | Port for the web server (0 = random port)        |
+
+### Permissions
+
+`pty-auto` deliberately does **not** use OpenCode's `permission.bash` setting to approve or deny PTY commands. This lets you disable the built-in `bash` tool globally while still allowing agents to use `pty_spawn` as a separate tool call.
+
+Every `pty_spawn` call must include a positive integer `timeoutSeconds` value. The timeout is the primary safety boundary for long-running and interactive work.
+
+`permission.external_directory` is still respected for PTY working directories outside the current project. Set it to `deny` if you want to block out-of-project PTY sessions.
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["pty-auto"],
+  "permission": {
+    "bash": "deny",
+    "external_directory": "deny"
+  }
+}
+```
+
+## How It Works
+
+1. **Spawn**: Creates a PTY using [bun-pty](https://github.com/nicksrandall/bun-pty), runs command in background with a required positive `timeoutSeconds` budget
+2. **Buffer**: Output is captured into a rolling line buffer (ring buffer)
+3. **Read**: Agent can read buffer anytime with offset/limit pagination
+4. **Filter**: Optional regex pattern filters lines before pagination
+5. **Write**: Agent can send any input including escape sequences
+6. **Lifecycle**: Sessions track status (running/exited/killed), persist until cleanup
+7. **Notify**: When `notifyOnExit` is true, sends a message to the session when the process exits
+8. **Web UI**: React frontend connects via WebSocket for real-time updates
+
+## Session Lifecycle
+
+```
+spawn → running → [exited | killed]
+                      ↓
+              (stays in list until cleanup=true)
+```
+
+Sessions remain in the list after exit so the agent can:
+
+- Read final output
+- Check exit code
+- Compare logs between runs
+
+Use `pty_kill` with `cleanup=true` to remove completely.
+
+## Local Development
+
+```bash
+git clone https://github.com/zjm54321/pty-auto.git
+cd pty-auto
+bun ci          # install packages from bun.lock
+bun lint        # Runs Biome linting checks
+bun format      # Runs Biome formatting checks
+bun typecheck   # Runs TypeScript type checking
+bun build:dev   # Build the React app for development
+bun unittest    # Runs the unit tests
+bun test:e2e    # Runs the e2e tests
+```
+
+To load a local checkout in OpenCode:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["file:///absolute/path/to/pty-auto/index.ts"]
+}
+```
+
+## Diagrams
+
+### Sequence
+
+#### Use Case 1 – Opening the PTY Monitor Web UI
+
+```mermaid
+sequenceDiagram
+    participant User as Human User
+    participant Chat as OpenCode Chat
+    participant Core as OpenCode Core
+    participant Plugin as PTY Plugin
+    participant Manager as PTY Manager (in Plugin)
+    participant WS as WebSocket Server (in Plugin)
+    participant Browser as Web Browser
+
+    Note over Plugin,WS: Plugin starts/owns the WS server and Manager
+
+    User->>Chat: Types /pty-open-background-spy
+    Chat->>Core: Slash command received
+    Core->>Plugin: Dispatches to registered command handler
+    Plugin->>Browser: open(server.url.origin)
+    activate Browser
+    Browser->>WS: Connects → ws://.../ws
+    WS->>Manager: Queries for current sessions (manager.list())
+    Manager-->>WS: Returns session data
+    WS-->>Browser: Sends session_list + subscribes to updates
+    Browser-->>User: PTY monitor UI appears (sessions + terminals)
+```
+
+#### Use Case 2 – Starting a Long-Running Background Process
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant Chat as OpenCode Chat
+    participant Agent as AI Agent
+    participant Plugin as PTY Plugin
+    participant Manager as PTY Manager
+    participant PTY as bun-pty Process
+    participant WS as WebSocket Server
+    participant UI as PTY Web UI (optional)
+
+    User->>Chat: "start vite dev server in background"
+    Chat->>Agent: User message
+    Agent->>Plugin: Calls pty_spawn(command="vite", args=["dev"], ...)
+    Plugin->>Manager: spawn(options)
+    Manager->>PTY: Launches real process
+    activate PTY
+    PTY-->>Manager: stdout/stderr chunks
+    Manager->>Manager: Appends to RingBuffer
+    Manager->>WS: Publishes raw_data + session_update
+    alt UI already open
+        WS-->>UI: Real-time terminal output
+        UI-->>User: Live xterm.js view
+    end
+    Plugin-->>Agent: Returns session info
+    Agent-->>Chat: "Dev server started (ID: pty_abc123)"
+    Chat-->>User: Confirmation message
+```
+
+#### Use Case 3 – Sending Interactive Input to a Running Session
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant UI as PTY Web UI
+    participant WS as WebSocket Server
+    participant Manager as PTY Manager
+    participant PTY as bun-pty Process
+
+    %% Variant A: Human typing in browser (most common)
+    User->>UI: Types "rs<Enter>" or pastes text
+    UI->>WS: Sends {type:"input", sessionId, data:"rs\n"}
+    WS->>Manager: write(sessionId, data)
+    Manager->>PTY: process.write(data)
+    PTY-->>Manager: New output (restart message, etc.)
+    Manager->>WS: Publishes raw_data
+    WS-->>UI: Updates xterm.js live
+
+    %% Variant B: AI sending input
+    Note over User,UI: Alternative path – AI controlled
+    Agent->>Plugin: pty_write(id, "\x03")  // e.g. Ctrl+C
+    Plugin->>Manager: write(id, data)
+    Manager->>PTY: process.write("\x03")
+```
+
+#### Use Case 4 – Reading Output / Logs On Demand
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant Chat
+    participant Agent as AI Agent
+    participant Plugin as PTY Plugin
+    participant Manager as PTY Manager
+    participant Buffer as RingBuffer
+
+    User->>Chat: "show me the last 200 lines of the dev server"
+    Chat->>Agent: User question
+    Agent->>Plugin: pty_read(id, offset?, limit=200, pattern?)
+    Plugin->>Manager: read / search request
+    Manager->>Buffer: read(offset, limit) or search(pattern)
+    Buffer-->>Manager: Matching / paginated lines
+    Manager-->>Plugin: Raw or formatted lines
+    Plugin-->>Agent: Text response
+    Agent-->>Chat: "Here are the logs:\n\n1 | [vite] ... \n..."
+    Chat-->>User: Logs displayed in chat
+```
+
+#### Use Case 5A – Killing / Cleaning Up a Session via Web UI
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant UI as PTY Web UI
+    participant HTTP as HTTP Server
+    participant Manager as PTY Manager
+    participant PTY as bun-pty Process
+    participant WS as WebSocket Server
+
+    Note over PTY: Assuming PTY is active (running process)<br>notifyOnExit = false (no chat notification,<br>but WS/UI always gets status updates)
+
+    activate PTY
+
+    User->>UI: Clicks "Kill" / "×" on session
+    UI->>HTTP: DELETE /api/sessions/:id  (or /cleanup)
+    HTTP->>Manager: kill(id, cleanup?)
+    Manager->>PTY: Sends SIGTERM (if running)
+    PTY-->>Manager: onExit event (code, signal)
+    deactivate PTY
+    Manager->>WS: Publishes session_update (status: killed/exited)
+    WS-->>UI: UI updates → shows "exited" or removes entry
+```
+
+#### Use Case 5B – Killing / Cleaning Up a Session via Agent
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant Chat as OpenCode Chat
+    participant Agent as AI Agent
+    participant Plugin as PTY Plugin
+    participant Manager as PTY Manager
+    participant PTY as bun-pty Process
+    participant WS as WebSocket Server
+    participant UI as PTY Web UI (optional)
+
+    Note over PTY: Assuming PTY is active (running process)<br>notifyOnExit = false (no chat notification,<br>but WS/UI always gets status updates)
+
+    activate PTY
+
+    User->>Chat: "kill the dev server"
+    Chat->>Agent: User request
+    Agent->>Plugin: pty_kill(id, cleanup=true)
+    Plugin->>Manager: kill(id, true)
+    Manager->>PTY: SIGTERM + remove from list (if cleanup)
+    PTY-->>Manager: onExit event (code, signal)
+    deactivate PTY
+    Manager->>WS: Broadcast session_update (status: killed/exited)
+    alt UI open
+        WS-->>UI: UI updates → shows "exited" or removes entry
+    end
+    Plugin-->>Agent: Success response
+    Agent-->>Chat: "Session killed"
+    Chat-->>User: Confirmation in chat
+```
+
+#### Use Case 6 – Automatic Exit Notification
+
+```mermaid
+sequenceDiagram
+    participant PTY as bun-pty Process
+    participant Manager as PTY Manager
+    participant Plugin as PTY Plugin
+    participant Chat as OpenCode Chat
+    participant Agent as AI Agent
+    participant User
+
+    %%{init: {'sequence': {'messageAlign': 'left'}}}%%
+
+    activate PTY
+    Note over PTY: Long-running process (dev server, tests, etc.)
+    PTY-->>Manager: Process exits → exitCode
+    deactivate PTY
+    alt notifyOnExit was true when spawned
+        Manager->>Plugin: Triggers exit notification
+        Plugin->>Chat: Sends formatted message via SDK<br><pty_exited><br>ID: pty_abc123<br>Exit: 0<br>Lines: 342<br>Last: Server running at http://localhost:5173<br></pty_exited>
+        Chat-->>User: Notification appears in chat
+        Chat->>Agent: Triggers agent with exit message
+    end
+    Manager->>WS: Publishes final session_update (status: exited)
+    alt UI open
+        WS-->>UI: UI shows red "exited" badge / stops live output
+    end
+```
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a PR.
+
+## Credits
+
+- [OpenCode](https://opencode.ai) - The AI coding assistant this plugin extends
+- [bun-pty](https://github.com/nicksrandall/bun-pty) - Cross-platform PTY for Bun

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { PTYPlugin } from './src/plugin.ts';
+export { PTYPlugin as server } from './src/plugin.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,SAAS,IAAI,MAAM,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export { PTYPlugin } from "./src/plugin.js";
+export { PTYPlugin as server } from "./src/plugin.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,SAAS,IAAI,MAAM,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/src/plugin/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const DEFAULT_TERMINAL_COLS = 120;
+export declare const DEFAULT_TERMINAL_ROWS = 40;
+export declare const NOTIFICATION_LINE_TRUNCATE = 250;
+export declare const NOTIFICATION_TITLE_TRUNCATE = 64;
+//# sourceMappingURL=constants.d.ts.map

package/dist/src/plugin/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/plugin/constants.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB,MAAM,CAAA;AACxC,eAAO,MAAM,qBAAqB,KAAK,CAAA;AACvC,eAAO,MAAM,0BAA0B,MAAM,CAAA;AAC7C,eAAO,MAAM,2BAA2B,KAAK,CAAA"}

package/dist/src/plugin/constants.js

@@ -0,0 +1,7 @@
+// Shared constants for the PTY plugin
+// PTY terminal and UI constants
+export const DEFAULT_TERMINAL_COLS = 120;
+export const DEFAULT_TERMINAL_ROWS = 40;
+export const NOTIFICATION_LINE_TRUNCATE = 250;
+export const NOTIFICATION_TITLE_TRUNCATE = 64;
+//# sourceMappingURL=constants.js.map

package/dist/src/plugin/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/plugin/constants.ts"],"names":[],"mappings":"AAAA,sCAAsC;AAEtC,gCAAgC;AAChC,MAAM,CAAC,MAAM,qBAAqB,GAAG,GAAG,CAAA;AACxC,MAAM,CAAC,MAAM,qBAAqB,GAAG,EAAE,CAAA;AACvC,MAAM,CAAC,MAAM,0BAA0B,GAAG,GAAG,CAAA;AAC7C,MAAM,CAAC,MAAM,2BAA2B,GAAG,EAAE,CAAA"}

package/dist/src/plugin/pty/buffer.d.ts

@@ -0,0 +1,19 @@
+export interface SearchMatch {
+    lineNumber: number;
+    text: string;
+}
+export declare class RingBuffer {
+    private buffer;
+    private maxSize;
+    constructor(maxSize?: number);
+    append(data: string): void;
+    private splitBufferLines;
+    read(offset?: number, limit?: number): string[];
+    readRaw(): string;
+    search(pattern: RegExp): SearchMatch[];
+    get length(): number;
+    get byteLength(): number;
+    flush(): void;
+    clear(): void;
+}
+//# sourceMappingURL=buffer.d.ts.map

package/dist/src/plugin/pty/buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer.d.ts","sourceRoot":"","sources":["../../../../src/plugin/pty/buffer.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,MAAM,CAAA;CACb;AAED,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,OAAO,CAAQ;gBAEX,OAAO,GAAE,MAAgC;IAIrD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAO1B,OAAO,CAAC,gBAAgB;IASxB,IAAI,CAAC,MAAM,GAAE,MAAU,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE;IAQlD,OAAO,IAAI,MAAM;IAIjB,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,EAAE;IAatC,IAAI,MAAM,IAAI,MAAM,CAInB;IAED,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,KAAK,IAAI,IAAI;IAIb,KAAK,IAAI,IAAI;CAGd"}

package/dist/src/plugin/pty/buffer.js

@@ -0,0 +1,61 @@
+// Default buffer size in characters (approximately 1MB)
+const DEFAULT_MAX_BUFFER_SIZE = parseInt(process.env.PTY_MAX_BUFFER_SIZE || '1000000', 10);
+export class RingBuffer {
+    buffer = '';
+    maxSize;
+    constructor(maxSize = DEFAULT_MAX_BUFFER_SIZE) {
+        this.maxSize = maxSize;
+    }
+    append(data) {
+        this.buffer += data;
+        if (this.buffer.length > this.maxSize) {
+            this.buffer = this.buffer.slice(-this.maxSize);
+        }
+    }
+    splitBufferLines() {
+        const lines = this.buffer.split('\n');
+        // Remove empty string at end if buffer doesn't end with newline
+        if (lines.length && lines[lines.length - 1] === '') {
+            lines.pop();
+        }
+        return lines;
+    }
+    read(offset = 0, limit) {
+        if (this.buffer === '')
+            return [];
+        const lines = this.splitBufferLines();
+        const start = Math.max(0, offset);
+        const end = limit !== undefined ? start + limit : lines.length;
+        return lines.slice(start, end);
+    }
+    readRaw() {
+        return this.buffer;
+    }
+    search(pattern) {
+        const matches = [];
+        const lines = this.splitBufferLines();
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (line && pattern.test(line)) {
+                matches.push({ lineNumber: i + 1, text: line });
+            }
+        }
+        return matches;
+    }
+    get length() {
+        if (this.buffer === '')
+            return 0;
+        const lines = this.splitBufferLines();
+        return lines.length;
+    }
+    get byteLength() {
+        return this.buffer.length;
+    }
+    flush() {
+        // No-op in new implementation
+    }
+    clear() {
+        this.buffer = '';
+    }
+}
+//# sourceMappingURL=buffer.js.map

package/dist/src/plugin/pty/buffer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer.js","sourceRoot":"","sources":["../../../../src/plugin/pty/buffer.ts"],"names":[],"mappings":"AAAA,wDAAwD;AACxD,MAAM,uBAAuB,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,mBAAmB,IAAI,SAAS,EAAE,EAAE,CAAC,CAAA;AAO1F,MAAM,OAAO,UAAU;IACb,MAAM,GAAW,EAAE,CAAA;IACnB,OAAO,CAAQ;IAEvB,YAAY,UAAkB,uBAAuB;QACnD,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;IACxB,CAAC;IAED,MAAM,CAAC,IAAY;QACjB,IAAI,CAAC,MAAM,IAAI,IAAI,CAAA;QACnB,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;YACtC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;QAChD,CAAC;IACH,CAAC;IAEO,gBAAgB;QACtB,MAAM,KAAK,GAAa,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QAC/C,gEAAgE;QAChE,IAAI,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC;YACnD,KAAK,CAAC,GAAG,EAAE,CAAA;QACb,CAAC;QACD,OAAO,KAAK,CAAA;IACd,CAAC;IAED,IAAI,CAAC,SAAiB,CAAC,EAAE,KAAc;QACrC,IAAI,IAAI,CAAC,MAAM,KAAK,EAAE;YAAE,OAAO,EAAE,CAAA;QACjC,MAAM,KAAK,GAAa,IAAI,CAAC,gBAAgB,EAAE,CAAA;QAC/C,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAAA;QACjC,MAAM,GAAG,GAAG,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAA;QAC9D,OAAO,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,CAAA;IAChC,CAAC;IAED,OAAO;QACL,OAAO,IAAI,CAAC,MAAM,CAAA;IACpB,CAAC;IAED,MAAM,CAAC,OAAe;QACpB,MAAM,OAAO,GAAkB,EAAE,CAAA;QACjC,MAAM,KAAK,GAAa,IAAI,CAAC,gBAAgB,EAAE,CAAA;QAE/C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACtC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;YACrB,IAAI,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC/B,OAAO,CAAC,IAAI,CAAC,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAA;YACjD,CAAC;QACH,CAAC;QACD,OAAO,OAAO,CAAA;IAChB,CAAC;IAED,IAAI,MAAM;QACR,IAAI,IAAI,CAAC,MAAM,KAAK,EAAE;YAAE,OAAO,CAAC,CAAA;QAChC,MAAM,KAAK,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAA;QACrC,OAAO,KAAK,CAAC,MAAM,CAAA;IACrB,CAAC;IAED,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAAA;IAC3B,CAAC;IAED,KAAK;QACH,8BAA8B;IAChC,CAAC;IAED,KAAK;QACH,IAAI,CAAC,MAAM,GAAG,EAAE,CAAA;IAClB,CAAC;CACF"}

package/dist/src/plugin/pty/formatters.d.ts

@@ -0,0 +1,4 @@
+import type { PTYSessionInfo } from './types.ts';
+export declare function formatSessionInfo(session: PTYSessionInfo): string[];
+export declare function formatLine(line: string, lineNum: number, maxLength?: number): string;
+//# sourceMappingURL=formatters.d.ts.map

package/dist/src/plugin/pty/formatters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatters.d.ts","sourceRoot":"","sources":["../../../../src/plugin/pty/formatters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAEhD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,cAAc,GAAG,MAAM,EAAE,CAgBnE;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,GAAE,MAAa,GAAG,MAAM,CAI1F"}