open-agents-ai 0.138.1 → 0.138.3

package/dist/index.js

@@ -39875,20 +39875,30 @@ if __name__ == '__main__':
         }
         if (!existsSync35(wavPath))
           return;
-        if (volume !== 1) {
-          try {
-            const wavData = readFileSync24(wavPath);
-            if (wavData.length > 44) {
-              const samples = new Int16Array(wavData.buffer, wavData.byteOffset + 44, (wavData.length - 44) / 2);
+        try {
+          const wavData = readFileSync24(wavPath);
+          if (wavData.length > 44) {
+            const sampleRate = wavData.readUInt32LE(24);
+            const samples = new Int16Array(wavData.buffer, wavData.byteOffset + 44, (wavData.length - 44) / 2);
+            const fadeInSamples = Math.min(Math.round(sampleRate * 0.2), samples.length);
+            for (let i = 0; i < fadeInSamples; i++) {
+              samples[i] = Math.round(samples[i] * (i / fadeInSamples));
+            }
+            const fadeOutSamples = Math.min(Math.round(sampleRate * 0.05), samples.length);
+            const fadeOutStart = samples.length - fadeOutSamples;
+            for (let i = 0; i < fadeOutSamples; i++) {
+              samples[fadeOutStart + i] = Math.round(samples[fadeOutStart + i] * (1 - i / fadeOutSamples));
+            }
+            if (volume !== 1) {
               for (let i = 0; i < samples.length; i++) {
                 samples[i] = Math.round(samples[i] * volume);
               }
-              const header = wavData.subarray(0, 44);
-              const scaled = Buffer.concat([header, Buffer.from(samples.buffer, samples.byteOffset, samples.byteLength)]);
-              writeFileSync14(wavPath, scaled);
             }
-          } catch {
+            const header = wavData.subarray(0, 44);
+            const scaled = Buffer.concat([header, Buffer.from(samples.buffer, samples.byteOffset, samples.byteLength)]);
+            writeFileSync14(wavPath, scaled);
           }
+        } catch {
         }
         if (pitchFactor !== 1) {
           try {
@@ -39936,6 +39946,7 @@ if __name__ == '__main__':
           }
         }
         await this.playWav(wavPath);
+        await this.sleep(80);
         try {
           unlinkSync8(wavPath);
         } catch {
@@ -45151,6 +45162,8 @@ var init_stream_renderer = __esm({
       startTime = 0;
       /** Track if we're mid-tool-arg display */
       inToolArgs = false;
+      /** Optional callback to capture rendered lines for scrollback buffer */
+      onRenderedLine = null;
       /**
        * Track accumulated content size for JSON blob detection.
        * When a non-newline JSON blob exceeds this threshold, suppress rendering.
@@ -45338,9 +45351,18 @@ var init_stream_renderer = __esm({
         this.writeRaw(dimText(prefix) + rendered + (hasNewline ? "\n" : ""));
         this.lineStarted = !hasNewline;
       }
-      /** Write raw ANSI text to stdout */
+      /** Write raw ANSI text to stdout and capture for scrollback */
       writeRaw(text) {
         process.stdout.write(text);
+        if (this.onRenderedLine) {
+          const parts = text.split("\n");
+          for (let i = 0; i < parts.length - 1; i++) {
+            this.onRenderedLine(parts[i]);
+          }
+          if (parts.length === 1 && parts[0].length > 0) {
+            this.onRenderedLine(parts[0]);
+          }
+        }
       }
       /** Flush partial buffer (non-newline-terminated tokens) */
       flushPartial(kind) {
@@ -50755,6 +50777,12 @@ var init_status_bar = __esm({
       };
       active = false;
       scrollRegionTop = 1;
+      // Virtual scrollback buffer — stores content lines for Page Up/Down scrolling.
+      // Since we're in alternate screen buffer, there's no native scrollback.
+      _contentLines = [];
+      _contentScrollOffset = 0;
+      // 0 = live (bottom), >0 = scrolled back
+      _contentMaxLines = 1e4;
       stdinHooked = false;
       /** COHERE distributed cognitive commons active flag */
       _cohereActive = false;
@@ -51496,6 +51524,76 @@ var init_status_bar = __esm({
           this.renderFooterAndPositionInput();
         }
       }
+      // -----------------------------------------------------------------------
+      // Content scrollback — virtual scroll through buffered output lines
+      // -----------------------------------------------------------------------
+      /** Record a content line for scrollback. Called by the stream renderer intercept. */
+      bufferContentLine(line) {
+        this._contentLines.push(line);
+        if (this._contentLines.length > this._contentMaxLines) {
+          this._contentLines.splice(0, this._contentLines.length - this._contentMaxLines);
+          if (this._contentScrollOffset > 0) {
+            this._contentScrollOffset = Math.min(this._contentScrollOffset, Math.max(0, this._contentLines.length - this.contentHeight));
+          }
+        }
+      }
+      /** Number of visible content rows */
+      get contentHeight() {
+        const rows = process.stdout.rows ?? 24;
+        return Math.max(1, rows - (this.scrollRegionTop - 1) - this._currentFooterHeight);
+      }
+      /** Whether user has scrolled back from live */
+      get isScrolledBack() {
+        return this._contentScrollOffset > 0;
+      }
+      /** Scroll up through content history */
+      scrollContentUp(lines = 1) {
+        if (!this.active)
+          return;
+        const maxOffset = Math.max(0, this._contentLines.length - this.contentHeight);
+        this._contentScrollOffset = Math.min(maxOffset, this._contentScrollOffset + lines);
+        this.repaintContent();
+      }
+      /** Scroll down through content history */
+      scrollContentDown(lines = 1) {
+        if (!this.active)
+          return;
+        this._contentScrollOffset = Math.max(0, this._contentScrollOffset - lines);
+        this.repaintContent();
+      }
+      /** Page up — scroll by visible height */
+      pageUpContent() {
+        this.scrollContentUp(Math.max(1, this.contentHeight - 2));
+      }
+      /** Page down — scroll by visible height */
+      pageDownContent() {
+        this.scrollContentDown(Math.max(1, this.contentHeight - 2));
+      }
+      /** Jump to live (End key) */
+      jumpToLive() {
+        this._contentScrollOffset = 0;
+        this.repaintContent();
+      }
+      /** Repaint content area from buffer at current scroll position.
+       *  Uses direct cursor positioning (btop-style) — no DECSTBM scrolling. */
+      repaintContent() {
+        const h = this.contentHeight;
+        const totalLines = this._contentLines.length;
+        const startIdx = Math.max(0, totalLines - h - this._contentScrollOffset);
+        let buf = "\x1B7\x1B[?25l";
+        for (let row = 0; row < h; row++) {
+          const lineIdx = startIdx + row;
+          const line = lineIdx < totalLines ? this._contentLines[lineIdx] : "";
+          const screenRow = this.scrollRegionTop + row;
+          buf += `\x1B[${screenRow};1H\x1B[2K${line}`;
+        }
+        if (this._contentScrollOffset > 0) {
+          const linesAbove = Math.max(0, totalLines - h - this._contentScrollOffset);
+          buf += `\x1B[${this.scrollRegionTop};1H\x1B[7m \u2191 ${linesAbove} lines above (PgDn/End to return) \x1B[0m`;
+        }
+        buf += "\x1B8\x1B[?25h";
+        process.stdout.write(buf);
+      }
       /**
        * Clear the input row and position cursor there at column 1.
        * Used by showPrompt() before readline writes the prompt.
@@ -52914,9 +53012,23 @@ ${entry.fullContent}`
       return;
     }
     if (statusBar?.isActive) {
+      const origWrite = process.stdout.write;
+      const boundWrite = origWrite.bind(process.stdout);
+      process.stdout.write = ((chunk, ...args) => {
+        const text = typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
+        for (const line of text.split("\n")) {
+          if (line.length > 0)
+            statusBar.bufferContentLine(line);
+        }
+        return boundWrite(chunk, ...args);
+      });
       statusBar.beginContentWrite();
-      fn();
-      statusBar.endContentWrite();
+      try {
+        fn();
+      } finally {
+        process.stdout.write = origWrite;
+        statusBar.endContentWrite();
+      }
     } else {
       fn();
     }
@@ -53481,6 +53593,7 @@ async function startInteractive(config, repoPath) {
   let adminSessionKey = null;
   const callSubAgents = /* @__PURE__ */ new Map();
   const streamRenderer = new StreamRenderer();
+  streamRenderer.onRenderedLine = (line) => statusBar.bufferContentLine(line);
   if (savedSettings.voice) {
     voiceEngine.toggle().catch((err) => {
       const msg = err instanceof Error ? err.message : String(err);
@@ -55844,6 +55957,28 @@ ${c2.dim("(Use /quit to exit)")}
     process.stdin.on("keypress", (_str, key) => {
       if (!key)
         return;
+      if (key.name === "pageup" || key.shift && key.name === "up") {
+        statusBar.pageUpContent();
+        return;
+      }
+      if (key.name === "pagedown" || key.shift && key.name === "down") {
+        statusBar.pageDownContent();
+        return;
+      }
+      if (key.name === "end" && key.ctrl) {
+        statusBar.jumpToLive();
+        return;
+      }
+      if (key.sequence) {
+        if (key.sequence.includes("[<65;") || key.sequence === "\x1B[A" && key.shift) {
+          statusBar.scrollContentUp(3);
+          return;
+        }
+        if (key.sequence.includes("[<64;") || key.sequence === "\x1B[B" && key.shift) {
+          statusBar.scrollContentDown(3);
+          return;
+        }
+      }
       if (key.name === "escape" && activeTask) {
         if (!activeTask.runner.isPaused) {
           activeTask.runner.pause();

package/package.json

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