open-agents-ai 0.184.94 → 0.184.95

package/dist/index.js

@@ -31532,7 +31532,7 @@ var require_validation = __commonJS({
 var require_receiver = __commonJS({
   "node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/receiver.js"(exports, module) {
     "use strict";
-    var { Writable: Writable2 } = __require("stream");
+    var { Writable } = __require("stream");
     var PerMessageDeflate = require_permessage_deflate();
     var {
       BINARY_TYPES,
@@ -31550,7 +31550,7 @@ var require_receiver = __commonJS({
     var GET_DATA = 4;
     var INFLATING = 5;
     var DEFER_EVENT = 6;
-    var Receiver2 = class extends Writable2 {
+    var Receiver2 = class extends Writable {
       /**
        * Creates a Receiver instance.
        *
@@ -32994,7 +32994,7 @@ var require_extension = __commonJS({
 var require_websocket = __commonJS({
   "node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/websocket.js"(exports, module) {
     "use strict";
-    var EventEmitter7 = __require("events");
+    var EventEmitter8 = __require("events");
     var https2 = __require("https");
     var http2 = __require("http");
     var net = __require("net");
@@ -33026,7 +33026,7 @@ var require_websocket = __commonJS({
     var protocolVersions = [8, 13];
     var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
     var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
-    var WebSocket2 = class _WebSocket extends EventEmitter7 {
+    var WebSocket2 = class _WebSocket extends EventEmitter8 {
       /**
        * Create a new `WebSocket`.
        *
@@ -34023,7 +34023,7 @@ var require_subprotocol = __commonJS({
 var require_websocket_server = __commonJS({
   "node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/websocket-server.js"(exports, module) {
     "use strict";
-    var EventEmitter7 = __require("events");
+    var EventEmitter8 = __require("events");
     var http2 = __require("http");
     var { Duplex } = __require("stream");
     var { createHash: createHash7 } = __require("crypto");
@@ -34036,7 +34036,7 @@ var require_websocket_server = __commonJS({
     var RUNNING = 0;
     var CLOSING = 1;
     var CLOSED = 2;
-    var WebSocketServer2 = class extends EventEmitter7 {
+    var WebSocketServer2 = class extends EventEmitter8 {
       /**
        * Create a `WebSocketServer` instance.
        *
@@ -40311,7 +40311,7 @@ function tuiSelect(opts) {
       }
       if (rl) {
         rl.resume();
-        rl.prompt(false);
+        rl.prompt?.(false);
       }
     }
     function onData(chunk) {
@@ -62320,6 +62320,37 @@ ${CONTENT_BG_SEQ}`);
           }
         };
       }
+      /**
+       * Hook into DirectInput — the blessed-style replacement for readline.
+       * DirectInput emits named events for all special keys, so no monkey-patching needed.
+       */
+      hookDirectInput(di, onEscape, onCtrlO) {
+        const self = this;
+        if (onEscape)
+          di.on("escape", () => onEscape());
+        if (onCtrlO)
+          di.on("ctrl-o", () => onCtrlO());
+        di.on("pageup", () => self.pageUpContent());
+        di.on("pagedown", () => self.pageDownContent());
+        di.on("shiftup", () => self.scrollContentUp(3));
+        di.on("shiftdown", () => self.scrollContentDown(3));
+        di.on("tab-empty", () => self.cycleFocus());
+        di.on("ctrl-backslash", () => self.cycleFocus());
+        di.on("up", () => {
+          if (self.writeDepth > 0 || self._contentScrollOffset > 0) {
+            self.scrollContentUp(1);
+          } else {
+            di.historyUp();
+          }
+        });
+        di.on("down", () => {
+          if (self.writeDepth > 0 || self._contentScrollOffset > 0) {
+            self.scrollContentDown(1);
+          } else {
+            di.historyDown();
+          }
+        });
+      }
       hookStdin() {
         if (this.stdinHooked)
           return;
@@ -62439,6 +62470,405 @@ var init_mouse_filter = __esm({
   }
 });
 
+// packages/cli/dist/tui/direct-input.js
+var direct_input_exports = {};
+__export(direct_input_exports, {
+  DirectInput: () => DirectInput
+});
+import { EventEmitter as EventEmitter7 } from "node:events";
+var DirectInput;
+var init_direct_input = __esm({
+  "packages/cli/dist/tui/direct-input.js"() {
+    "use strict";
+    DirectInput = class extends EventEmitter7 {
+      /** Current input line text */
+      line = "";
+      /** Cursor position within .line (0-based) */
+      cursor = 0;
+      _history;
+      _historySize;
+      _historyIndex = -1;
+      _savedLine = "";
+      // saved current input when navigating history
+      _completer = null;
+      _paused = false;
+      _closed = false;
+      _input;
+      _buffer = "";
+      // partial escape sequence buffer
+      _flushTimer = null;
+      constructor(input, options) {
+        super();
+        this._input = input;
+        this._history = [...options?.history ?? []];
+        this._historySize = options?.historySize ?? 500;
+        this._completer = options?.completer ?? null;
+        input.on("data", (chunk) => {
+          if (this._paused || this._closed)
+            return;
+          this.feed(chunk.toString("utf8"));
+        });
+        input.on("end", () => {
+          if (!this._closed)
+            this.close();
+        });
+      }
+      /** Process raw input data — parse escape sequences and printable chars */
+      feed(data) {
+        this._buffer += data;
+        this._processBuffer();
+      }
+      /** Pause input processing (for overlay transitions) */
+      pause() {
+        this._paused = true;
+      }
+      /** Resume input processing */
+      resume() {
+        this._paused = false;
+      }
+      /** Close the input handler */
+      close() {
+        if (this._closed)
+          return;
+        this._closed = true;
+        if (this._flushTimer) {
+          clearTimeout(this._flushTimer);
+          this._flushTimer = null;
+        }
+        this.emit("close");
+      }
+      /** No-op — readline compat (StatusBar renders the prompt, not us) */
+      setPrompt(_prompt) {
+      }
+      /** No-op — readline compat */
+      prompt(_preserveCursor) {
+      }
+      /** Set the line content and cursor position (for Esc-to-recall) */
+      setLine(text, cursorPos) {
+        this.line = text;
+        this.cursor = cursorPos ?? text.length;
+      }
+      /** Navigate history up (older) */
+      historyUp() {
+        if (this._history.length === 0)
+          return;
+        if (this._historyIndex === -1) {
+          this._savedLine = this.line;
+        }
+        if (this._historyIndex < this._history.length - 1) {
+          this._historyIndex++;
+          this.line = this._history[this._historyIndex];
+          this.cursor = this.line.length;
+        }
+      }
+      /** Navigate history down (newer) */
+      historyDown() {
+        if (this._historyIndex <= -1)
+          return;
+        this._historyIndex--;
+        if (this._historyIndex === -1) {
+          this.line = this._savedLine;
+        } else {
+          this.line = this._history[this._historyIndex];
+        }
+        this.cursor = this.line.length;
+      }
+      // ---------------------------------------------------------------------------
+      // Private: buffer processing and escape sequence parsing
+      // ---------------------------------------------------------------------------
+      _processBuffer() {
+        let i = 0;
+        while (i < this._buffer.length) {
+          const ch = this._buffer[i];
+          const code = ch.charCodeAt(0);
+          if (code === 27) {
+            const remaining = this._buffer.slice(i);
+            if (remaining.length >= 2 && remaining[1] === "[") {
+              const csiMatch = remaining.match(/^\x1B\[([0-9;]*)([A-Za-z~])/);
+              if (csiMatch) {
+                this._handleCSI(csiMatch[1], csiMatch[2]);
+                i += csiMatch[0].length;
+                continue;
+              }
+              if (remaining.length < 10) {
+                break;
+              }
+              i += 2;
+              continue;
+            }
+            if (remaining.length >= 2 && remaining[1] === "O") {
+              if (remaining.length >= 3) {
+                this._handleSS3(remaining[2]);
+                i += 3;
+                continue;
+              }
+              break;
+            }
+            if (remaining.length === 1) {
+              break;
+            }
+            i++;
+            continue;
+          }
+          if (code < 32 || code === 127) {
+            this._handleControl(code);
+            i++;
+            continue;
+          }
+          const char = this._buffer[i];
+          this.line = this.line.slice(0, this.cursor) + char + this.line.slice(this.cursor);
+          this.cursor++;
+          i++;
+        }
+        this._buffer = this._buffer.slice(i);
+        if (this._buffer.length > 0) {
+          if (this._flushTimer)
+            clearTimeout(this._flushTimer);
+          this._flushTimer = setTimeout(() => {
+            this._flushTimer = null;
+            if (this._buffer.length > 0) {
+              if (this._buffer === "\x1B") {
+                this.emit("escape");
+              }
+              this._buffer = "";
+            }
+          }, 50);
+        } else {
+          if (this._flushTimer) {
+            clearTimeout(this._flushTimer);
+            this._flushTimer = null;
+          }
+        }
+      }
+      /** Handle CSI escape sequence: \x1B[ {params} {final} */
+      _handleCSI(params, final) {
+        switch (final) {
+          case "A":
+            if (params === "1;2") {
+              this.emit("shiftup");
+              return;
+            }
+            this.emit("up");
+            return;
+          case "B":
+            if (params === "1;2") {
+              this.emit("shiftdown");
+              return;
+            }
+            this.emit("down");
+            return;
+          case "C":
+            if (params === "1;5") {
+              this._wordRight();
+              return;
+            }
+            if (this.cursor < this.line.length)
+              this.cursor++;
+            return;
+          case "D":
+            if (params === "1;5") {
+              this._wordLeft();
+              return;
+            }
+            if (this.cursor > 0)
+              this.cursor--;
+            return;
+          case "H":
+            this.cursor = 0;
+            return;
+          case "F":
+            this.cursor = this.line.length;
+            return;
+          case "~":
+            if (params === "3") {
+              if (this.cursor < this.line.length) {
+                this.line = this.line.slice(0, this.cursor) + this.line.slice(this.cursor + 1);
+              }
+              return;
+            }
+            if (params === "5") {
+              this.emit("pageup");
+              return;
+            }
+            if (params === "6") {
+              this.emit("pagedown");
+              return;
+            }
+            return;
+          case "u":
+            return;
+        }
+      }
+      /** Handle SS3 sequence: \x1BO {final} (some terminals use this for arrows/Home/End) */
+      _handleSS3(final) {
+        switch (final) {
+          case "A":
+            this.emit("up");
+            return;
+          case "B":
+            this.emit("down");
+            return;
+          case "C":
+            if (this.cursor < this.line.length)
+              this.cursor++;
+            return;
+          case "D":
+            if (this.cursor > 0)
+              this.cursor--;
+            return;
+          case "H":
+            this.cursor = 0;
+            return;
+          case "F":
+            this.cursor = this.line.length;
+            return;
+        }
+      }
+      /** Handle control characters (ASCII < 32 and DEL) */
+      _handleControl(code) {
+        switch (code) {
+          case 13:
+          // Enter (CR)
+          case 10:
+            this._submit();
+            return;
+          case 127:
+          // Backspace (DEL)
+          case 8:
+            if (this.cursor > 0) {
+              this.line = this.line.slice(0, this.cursor - 1) + this.line.slice(this.cursor);
+              this.cursor--;
+            }
+            return;
+          case 3:
+            this.emit("SIGINT");
+            return;
+          case 4:
+            if (this.line.length === 0)
+              this.close();
+            return;
+          case 9:
+            this._handleTab();
+            return;
+          case 23:
+            this._deleteWordLeft();
+            return;
+          case 21:
+            this.line = this.line.slice(this.cursor);
+            this.cursor = 0;
+            return;
+          case 11:
+            this.line = this.line.slice(0, this.cursor);
+            return;
+          case 1:
+            this.cursor = 0;
+            return;
+          case 5:
+            this.cursor = this.line.length;
+            return;
+          case 15:
+            this.emit("ctrl-o");
+            return;
+          case 28:
+            this.emit("ctrl-backslash");
+            return;
+        }
+      }
+      /** Submit the current line */
+      _submit() {
+        const line = this.line;
+        if (line.trim() && (this._history.length === 0 || this._history[0] !== line)) {
+          this._history.unshift(line);
+          if (this._history.length > this._historySize) {
+            this._history.length = this._historySize;
+          }
+        }
+        this._historyIndex = -1;
+        this._savedLine = "";
+        this.line = "";
+        this.cursor = 0;
+        this.emit("line", line);
+      }
+      /** Handle Tab completion */
+      _handleTab() {
+        if (this.line.length === 0) {
+          this.emit("tab-empty");
+          return;
+        }
+        if (!this._completer)
+          return;
+        this._completer(this.line, (err, result) => {
+          if (err || !result)
+            return;
+          const [completions, substring] = result;
+          if (completions.length === 0)
+            return;
+          if (completions.length === 1) {
+            const completion = completions[0];
+            const before = this.line.slice(0, this.cursor);
+            const idx = before.lastIndexOf(substring);
+            if (idx >= 0) {
+              this.line = before.slice(0, idx) + completion + this.line.slice(this.cursor);
+              this.cursor = idx + completion.length;
+            }
+          } else if (completions.length > 1) {
+            let common = completions[0];
+            for (let i = 1; i < completions.length; i++) {
+              const other = completions[i];
+              let j = 0;
+              while (j < common.length && j < other.length && common[j] === other[j])
+                j++;
+              common = common.slice(0, j);
+            }
+            if (common.length > substring.length) {
+              const before = this.line.slice(0, this.cursor);
+              const idx = before.lastIndexOf(substring);
+              if (idx >= 0) {
+                this.line = before.slice(0, idx) + common + this.line.slice(this.cursor);
+                this.cursor = idx + common.length;
+              }
+            }
+          }
+        });
+      }
+      /** Move cursor left by one word */
+      _wordLeft() {
+        if (this.cursor === 0)
+          return;
+        let i = this.cursor - 1;
+        while (i > 0 && /\s/.test(this.line[i]))
+          i--;
+        while (i > 0 && /\S/.test(this.line[i - 1]))
+          i--;
+        this.cursor = i;
+      }
+      /** Move cursor right by one word */
+      _wordRight() {
+        if (this.cursor >= this.line.length)
+          return;
+        let i = this.cursor;
+        while (i < this.line.length && /\S/.test(this.line[i]))
+          i++;
+        while (i < this.line.length && /\s/.test(this.line[i]))
+          i++;
+        this.cursor = i;
+      }
+      /** Delete word left of cursor (Ctrl+W) */
+      _deleteWordLeft() {
+        if (this.cursor === 0)
+          return;
+        let i = this.cursor - 1;
+        while (i > 0 && /\s/.test(this.line[i]))
+          i--;
+        while (i > 0 && /\S/.test(this.line[i - 1]))
+          i--;
+        this.line = this.line.slice(0, i) + this.line.slice(this.cursor);
+        this.cursor = i;
+      }
+    };
+  }
+});
+
 // packages/cli/dist/api/profiles.js
 import { existsSync as existsSync51, readFileSync as readFileSync40, writeFileSync as writeFileSync24, mkdirSync as mkdirSync25, readdirSync as readdirSync19, unlinkSync as unlinkSync12 } from "node:fs";
 import { join as join68 } from "node:path";
@@ -64038,8 +64468,6 @@ var init_serve = __esm({
 });
 
 // packages/cli/dist/tui/interactive.js
-import * as readline2 from "node:readline";
-import { Writable } from "node:stream";
 import { cwd } from "node:process";
 import { resolve as resolve32, join as join70, dirname as dirname21, extname as extname11 } from "node:path";
 import { createRequire as createRequire4 } from "node:module";
@@ -65974,18 +66402,18 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
     } catch {
     }
   });
-  const rl = readline2.createInterface({
-    input: mouseFilter,
-    output: process.stdout,
-    prompt: idlePrompt,
-    terminal: true,
-    historySize: MAX_HISTORY_LINES,
+  const { DirectInput: DirectInput2 } = await Promise.resolve().then(() => (init_direct_input(), direct_input_exports));
+  const rl = new DirectInput2(mouseFilter, {
     history: savedHistory,
-    completer
+    historySize: MAX_HISTORY_LINES,
+    completer: (line, cb) => {
+      const result = completer(line);
+      cb(null, result);
+    }
   });
-  origTtyWriteRef = rl._ttyWrite?.bind(rl) ?? null;
+  origTtyWriteRef = null;
   let _escapeHandler = null;
-  statusBar.hookReadlineScroll(rl, () => {
+  statusBar.hookDirectInput(rl, () => {
     _escapeHandler?.();
   }, () => {
     if (sudoPromptPending) {
@@ -66028,7 +66456,6 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
       }
     })();
   });
-  rl.output = null;
   if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
     process.stdin.setRawMode(true);
   }
@@ -66053,7 +66480,6 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
   statusBar.setPromptText(idlePrompt, 2);
   statusBar.setCompletions(allCompletions);
   if (statusBar.isActive) {
-    rl.output = new Writable({ write: (_c, _e, cb) => cb() });
     statusBar.setInputStateProvider(() => ({
       line: rl.line ?? "",
       cursor: rl.cursor ?? 0
@@ -66980,7 +67406,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
           writeContent(() => renderInfo(`Heard: "${text}" ${c2.dim("(press Enter to submit)")}`));
         } else if (isFinal) {
           writeContent(() => renderInfo(`Auto-submitting: "${text}"`));
-          rl.write(text + "\n");
+          rl.feed(text + "\n");
         } else {
           writeContent(() => renderInfo(`Hearing: "${text}"`));
         }
@@ -67126,7 +67552,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
                   agent.handleTranscript(text);
                 }
                 if (callSubAgents.size === 0) {
-                  rl.write(text + "\n");
+                  rl.feed(text + "\n");
                 }
               }
             });
@@ -67733,7 +68159,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         const timedOut = result.timedOut === true;
         if (timedOut) {
           try {
-            rl.write?.("\x1B");
+            rl.feed("\x1B");
           } catch {
           }
           await new Promise((r) => setTimeout(r, 100));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.184.94",
+  "version": "0.184.95",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",