New Context Menu Item + Wsh Command to Save Scrollback of a Terminal Widget

cmd/wsh/cmd/wshcmd-termscrollback.go

@@ -0,0 +1,104 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/spf13/cobra"
+	"github.com/wavetermdev/waveterm/pkg/waveobj"
+	"github.com/wavetermdev/waveterm/pkg/wshrpc"
+	"github.com/wavetermdev/waveterm/pkg/wshrpc/wshclient"
+	"github.com/wavetermdev/waveterm/pkg/wshutil"
+)
+
+var termScrollbackCmd = &cobra.Command{
+	Use:   "termscrollback",
+	Short: "Get terminal scrollback from a terminal block",
+	Long: `Get the terminal scrollback from a terminal block.
+
+By default, retrieves all lines. You can specify line ranges or get the 
+output of the last command using the --lastcommand flag.`,
+	RunE:                  termScrollbackRun,
+	PreRunE:               preRunSetupRpcClient,
+	DisableFlagsInUseLine: true,
+}
+
+var (
+	termScrollbackLineStart  int
+	termScrollbackLineEnd    int
+	termScrollbackLastCmd    bool
+	termScrollbackOutputFile string
+)
+
+func init() {
+	rootCmd.AddCommand(termScrollbackCmd)
+
+	termScrollbackCmd.Flags().IntVar(&termScrollbackLineStart, "start", 0, "starting line number (0 = beginning)")
+	termScrollbackCmd.Flags().IntVar(&termScrollbackLineEnd, "end", 0, "ending line number (0 = all lines)")
+	termScrollbackCmd.Flags().BoolVar(&termScrollbackLastCmd, "lastcommand", false, "get output of last command (requires shell integration)")
+	termScrollbackCmd.Flags().StringVarP(&termScrollbackOutputFile, "output", "o", "", "write output to file instead of stdout")
+}
+
+func termScrollbackRun(cmd *cobra.Command, args []string) (rtnErr error) {
+	defer func() {
+		sendActivity("termscrollback", rtnErr == nil)
+	}()
+
+	// Resolve the block argument
+	fullORef, err := resolveBlockArg()
+	if err != nil {
+		return err
+	}
+
+	// Get block metadata to verify it's a terminal block
+	metaData, err := wshclient.GetMetaCommand(RpcClient, wshrpc.CommandGetMetaData{
+		ORef: *fullORef,
+	}, &wshrpc.RpcOpts{Timeout: 2000})
+	if err != nil {
+		return fmt.Errorf("error getting block metadata: %w", err)
+	}
+
+	// Check if the block is a terminal block
+	viewType, ok := metaData[waveobj.MetaKey_View].(string)
+	if !ok || viewType != "term" {
+		return fmt.Errorf("block %s is not a terminal block (view type: %s)", fullORef.OID, viewType)
+	}
+
+	// Make the RPC call to get scrollback
+	scrollbackData := wshrpc.CommandTermGetScrollbackLinesData{
+		LineStart:   termScrollbackLineStart,
+		LineEnd:     termScrollbackLineEnd,
+		LastCommand: termScrollbackLastCmd,
+	}
+
+	result, err := wshclient.TermGetScrollbackLinesCommand(RpcClient, scrollbackData, &wshrpc.RpcOpts{
+		Route:   wshutil.MakeFeBlockRouteId(fullORef.OID),
+		Timeout: 5000,
+	})
+	if err != nil {
+		return fmt.Errorf("error getting terminal scrollback: %w", err)
+	}
+
+	// Format the output
+	output := strings.Join(result.Lines, "\n")
+	if len(result.Lines) > 0 {
+		output += "\n" // Add final newline
+	}
+
+	// Write to file or stdout
+	if termScrollbackOutputFile != "" {
+		err = os.WriteFile(termScrollbackOutputFile, []byte(output), 0644)
+		if err != nil {
+			return fmt.Errorf("error writing to file %s: %w", termScrollbackOutputFile, err)
+		}
+		fmt.Printf("terminal scrollback written to %s (%d lines)\n", termScrollbackOutputFile, len(result.Lines))
+	} else {
+		fmt.Print(output)
+	}
+
+	return nil
+}

docs/docs/wsh-reference.mdx

@@ -792,6 +792,57 @@ wsh setvar -b client MYVAR=value
 
 Variables set with these commands persist across sessions and can be used to store configuration values, secrets, or any other string data that needs to be accessible across blocks or tabs.
 
+---
+
+## termscrollback
+
+Get the terminal scrollback from a terminal block. This is useful for capturing terminal output for processing or archiving.
+
+```sh
+wsh termscrollback [-b blockid] [flags]
+```
+
+By default, retrieves all lines from the current terminal block. You can specify line ranges or get only the output of the last command.
+
+Flags:
+
+- `-b, --block <blockid>` - specify target terminal block (default: current block)
+- `--start <line>` - starting line number (0 = beginning, default: 0)
+- `--end <line>` - ending line number (0 = all lines, default: 0)
+- `--lastcommand` - get output of last command (requires shell integration)
+- `-o, --output <file>` - write output to file instead of stdout
+
+Examples:
+
+```sh
+# Get all scrollback from current terminal
+wsh termscrollback
+
+# Get scrollback from a specific terminal block
+wsh termscrollback -b 2
+
+# Get only the last command's output
+wsh termscrollback --lastcommand
+
+# Get a specific line range (lines 100-200)
+wsh termscrollback --start 100 --end 200
+
+# Save scrollback to a file
+wsh termscrollback -o terminal-log.txt
+
+# Save last command output to a file
+wsh termscrollback --lastcommand -o last-output.txt
+
+# Process last command output with grep
+wsh termscrollback --lastcommand | grep "ERROR"
+```
+
+:::note
+The `--lastcommand` flag requires shell integration to be enabled. This feature allows you to capture just the output from the most recent command, which is particularly useful for scripting and automation.
+:::
+
+---
+
 ## wavepath
 
 The `wavepath` command lets you get the paths to various Wave Terminal directories and files, including configuration, data storage, and logs.

emain/emain-ipc.ts

@@ -470,4 +470,27 @@ export function initIpcHandlers() {
     electron.ipcMain.on("do-refresh", (event) => {
         event.sender.reloadIgnoringCache();
     });
+
+    electron.ipcMain.handle("save-text-file", async (event, fileName: string, content: string) => {
+        const ww = focusedWaveWindow;
+        if (ww == null) {
+            return false;
+        }
+        const result = await electron.dialog.showSaveDialog(ww, {
+            title: "Save Scrollback",
+            defaultPath: fileName || "session.log",
+            filters: [{ name: "Text Files", extensions: ["txt", "log"] }],
+        });
+        if (result.canceled || !result.filePath) {
+            return false;
+        }
+        try {
+            await fs.promises.writeFile(result.filePath, content, "utf-8");
+            console.log("saved scrollback to", result.filePath);
+            return true;
+        } catch (err) {
+            console.error("error saving scrollback file", err);
+            return false;
+        }
+    });
 }

emain/preload.ts

@@ -69,6 +69,7 @@ contextBridge.exposeInMainWorld("api", {
     openBuilder: (appId?: string) => ipcRenderer.send("open-builder", appId),
     setBuilderWindowAppId: (appId: string) => ipcRenderer.send("set-builder-window-appid", appId),
     doRefresh: () => ipcRenderer.send("do-refresh"),
+    saveTextFile: (fileName: string, content: string) => ipcRenderer.invoke("save-text-file", fileName, content),
 });
 
 // Custom event for "new-window"

frontend/app/view/term/term-model.ts

@@ -4,6 +4,7 @@
 import { WaveAIModel } from "@/app/aipanel/waveai-model";
 import { BlockNodeModel } from "@/app/block/blocktypes";
 import { appHandleKeyDown } from "@/app/store/keymodel";
+import { modalsModel } from "@/app/store/modalmodel";
 import type { TabModel } from "@/app/store/tab-model";
 import { waveEventSubscribe } from "@/app/store/wps";
 import { RpcApi } from "@/app/store/wshclientapi";
@@ -912,6 +913,36 @@ export class TermViewModel implements ViewModel {
             fullMenu.push({ type: "separator" });
         }
 
+        fullMenu.push({
+            label: "Save Session As...",
+            click: () => {
+                if (this.termRef.current) {
+                    const content = this.termRef.current.getScrollbackContent();
+                    if (content) {
+                        fireAndForget(async () => {
+                            try {
+                                const success = await getApi().saveTextFile("session.log", content);
+                                if (!success) {
+                                    console.log("Save scrollback cancelled by user");
+                                }
+                            } catch (error) {
+                                console.error("Failed to save scrollback:", error);
+                                const errorMessage = error?.message || "An unknown error occurred";
+                                modalsModel.pushModal("MessageModal", {
+                                    children: `Failed to save session scrollback: ${errorMessage}`,
+                                });
+                            }
+                        });
+                    } else {
+                        modalsModel.pushModal("MessageModal", {
+                            children: "No scrollback content to save.",
+                        });
+                    }
+                }
+            },
+        });
+        fullMenu.push({ type: "separator" });
+
         const submenu: ContextMenuItem[] = termThemeKeys.map((themeName) => {
             return {
                 label: termThemes[themeName]["display:name"] ?? themeName,

frontend/app/view/term/term-wsh.tsx

@@ -7,6 +7,7 @@ import { RpcResponseHelper, WshClient } from "@/app/store/wshclient";
 import { RpcApi } from "@/app/store/wshclientapi";
 import { makeFeBlockRouteId } from "@/app/store/wshrouter";
 import { TermViewModel } from "@/app/view/term/term-model";
+import { bufferLinesToText } from "@/app/view/term/termutil";
 import { isBlank } from "@/util/util";
 import debug from "debug";
 
@@ -120,36 +121,37 @@ export class TermWshClient extends WshClient {
 
         const buffer = termWrap.terminal.buffer.active;
         const totalLines = buffer.length;
-        const lines: string[] = [];
 
         if (data.lastcommand) {
             if (globalStore.get(termWrap.shellIntegrationStatusAtom) == null) {
                 throw new Error("Cannot get last command data without shell integration");
             }
 
-            let startLine = 0;
+            let startBufferIndex = 0;
+            let endBufferIndex = totalLines;
             if (termWrap.promptMarkers.length > 0) {
-                const lastMarker = termWrap.promptMarkers[termWrap.promptMarkers.length - 1];
-                const markerLine = lastMarker.line;
-                startLine = totalLines - markerLine;
-            }
-
-            const endLine = totalLines;
-            for (let i = startLine; i < endLine; i++) {
-                const bufferIndex = totalLines - 1 - i;
-                const line = buffer.getLine(bufferIndex);
-                if (line) {
-                    lines.push(line.translateToString(true));
+                // The last marker is the current prompt, so we want the second-to-last for the previous command
+                // If there's only one marker, use it (edge case for first command)
+                const markerIndex = termWrap.promptMarkers.length > 1
+                    ? termWrap.promptMarkers.length - 2
+                    : termWrap.promptMarkers.length - 1;
+                const commandStartMarker = termWrap.promptMarkers[markerIndex];
+                startBufferIndex = commandStartMarker.line;
+
+                // End at the last marker (current prompt) if there are multiple markers
+                if (termWrap.promptMarkers.length > 1) {
+                    const currentPromptMarker = termWrap.promptMarkers[termWrap.promptMarkers.length - 1];
+                    endBufferIndex = currentPromptMarker.line;
                 }
             }
 
-            lines.reverse();
+            const lines = bufferLinesToText(buffer, startBufferIndex, endBufferIndex);
 
             let returnLines = lines;
-            let returnStartLine = startLine;
+            let returnStartLine = startBufferIndex;
             if (lines.length > 1000) {
                 returnLines = lines.slice(lines.length - 1000);
-                returnStartLine = startLine + (lines.length - 1000);
+                returnStartLine = startBufferIndex + (lines.length - 1000);
             }
 
             return {
@@ -163,15 +165,9 @@ export class TermWshClient extends WshClient {
         const startLine = Math.max(0, data.linestart);
         const endLine = Math.min(totalLines, data.lineend);
 
-        for (let i = startLine; i < endLine; i++) {
-            const bufferIndex = totalLines - 1 - i;
-            const line = buffer.getLine(bufferIndex);
-            if (line) {
-                lines.push(line.translateToString(true));
-            }
-        }
-
-        lines.reverse();
+        const startBufferIndex = totalLines - endLine;
+        const endBufferIndex = totalLines - startLine;
+        const lines = bufferLinesToText(buffer, startBufferIndex, endBufferIndex);
 
         return {
             totallines: totalLines,

frontend/app/view/term/termutil.ts

@@ -4,6 +4,7 @@
 export const DefaultTermTheme = "default-dark";
 import { RpcApi } from "@/app/store/wshclientapi";
 import { TabRpcClient } from "@/app/store/wshrpcutil";
+import * as TermTypes from "@xterm/xterm";
 import base64 from "base64-js";
 import { colord } from "colord";
 
@@ -319,3 +320,65 @@ export async function extractAllClipboardData(e?: ClipboardEvent): Promise<Array
         return results;
     }
 }
+
+/**
+ * Converts terminal buffer lines to text, properly handling wrapped lines.
+ * Wrapped lines (long lines split across multiple buffer rows) are concatenated
+ * without adding newlines between them, while preserving actual line breaks.
+ *
+ * @param buffer - The xterm.js buffer to extract lines from
+ * @param startIndex - Starting buffer index (inclusive, 0-based)
+ * @param endIndex - Ending buffer index (exclusive, 0-based)
+ * @returns Array of logical lines (with wrapped lines concatenated)
+ */
+export function bufferLinesToText(buffer: TermTypes.IBuffer, startIndex: number, endIndex: number): string[] {
+    const lines: string[] = [];
+    let currentLine = "";
+    let isFirstLine = true;
+
+    // Clamp indices to valid buffer range to avoid out-of-bounds access on the
+    // underlying circular buffer, which could return stale/wrong data.
+    const clampedStart = Math.max(0, Math.min(startIndex, buffer.length));
+    const clampedEnd = Math.max(0, Math.min(endIndex, buffer.length));
+
+    for (let i = clampedStart; i < clampedEnd; i++) {
+        const line = buffer.getLine(i);
+        if (line) {
+            const lineText = line.translateToString(true);
+            // If this line is wrapped (continuation of previous line), concatenate without newline
+            if (line.isWrapped && !isFirstLine) {
+                currentLine += lineText;
+            } else {
+                // This is a new logical line
+                if (!isFirstLine) {
+                    lines.push(currentLine);
+                }
+                currentLine = lineText;
+                isFirstLine = false;
+            }
+        }
+    }
+
+    // Don't forget the last line
+    if (!isFirstLine) {
+        lines.push(currentLine);
+    }
+
+    // Trim trailing blank lines only when the requested range extends to the
+    // actual end of the buffer.  A terminal allocates a fixed number of rows
+    // (e.g. 80) but only the first few may contain real content; the rest are
+    // empty placeholder rows.  We strip those so callers don't receive a wall
+    // of empty strings.
+    //
+    // Crucially, if the caller requested a specific sub-range (e.g. lines
+    // 100-150) and lines 140-150 happen to be blank, those blanks are
+    // intentional and must NOT be removed.  We only trim when the range
+    // reaches the very end of the buffer.
+    if (clampedEnd >= buffer.length) {
+        while (lines.length > 0 && lines[lines.length - 1] === "") {
+            lines.pop();
+        }
+    }
+
+    return lines;
+}