first cut at reading terminal scrollback

Author: sawka

frontend/app/aipanel/aipanel.tsx

@@ -9,7 +9,6 @@ import { atoms, getSettingsKeyAtom } from "@/app/store/global";
 import { globalStore } from "@/app/store/jotaiStore";
 import { WorkspaceLayoutModel } from "@/app/workspace/workspace-layout-model";
 import { getWebServerEndpoint } from "@/util/endpoints";
-import { getElemAsStr } from "@/util/focusutil";
 import { checkKeyPressed, keydownWrapper } from "@/util/keyutil";
 import { cn } from "@/util/util";
 import { useChat } from "@ai-sdk/react";
@@ -251,7 +250,7 @@ const AIPanelComponentInner = memo(({ className, onClose }: AIPanelProps) => {
     };
 
     const handleFocusCapture = useCallback((event: React.FocusEvent) => {
-        console.log("Wave AI focus capture", getElemAsStr(event.target));
+        // console.log("Wave AI focus capture", getElemAsStr(event.target));
         focusManager.requestWaveAIFocus();
     }, []);
 

frontend/app/store/wshclientapi.ts

@@ -447,6 +447,11 @@ class RpcApiType {
         return client.wshRpcStream("streamwaveai", data, opts);
     }
 
+    // command "termgetscrollbacklines" [call]
+    TermGetScrollbackLinesCommand(client: WshClient, data: CommandTermGetScrollbackLinesData, opts?: RpcOpts): Promise<CommandTermGetScrollbackLinesRtnData> {
+        return client.wshRpcCall("termgetscrollbacklines", data, opts);
+    }
+
     // command "test" [call]
     TestCommand(client: WshClient, data: string, opts?: RpcOpts): Promise<void> {
         return client.wshRpcCall("test", data, opts);

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

@@ -103,4 +103,43 @@ export class TermWshClient extends WshClient {
             return oref;
         }
     }
+
+    async handle_termgetscrollbacklines(
+        rh: RpcResponseHelper,
+        data: CommandTermGetScrollbackLinesData
+    ): Promise<CommandTermGetScrollbackLinesRtnData> {
+        const termWrap = this.model.termRef.current;
+        if (!termWrap || !termWrap.terminal) {
+            return {
+                totallines: 0,
+                linestart: data.linestart,
+                lines: [],
+                lastupdated: 0,
+            };
+        }
+
+        const buffer = termWrap.terminal.buffer.active;
+        const totalLines = buffer.length;
+        const lines: string[] = [];
+
+        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();
+
+        return {
+            totallines: totalLines,
+            linestart: startLine,
+            lines: lines,
+            lastupdated: termWrap.lastUpdated,
+        };
+    }
 }

frontend/app/view/term/termwrap.ts

@@ -162,6 +162,7 @@ export class TermWrap {
     onSearchResultsDidChange?: (result: { resultIndex: number; resultCount: number }) => void;
     private toDispose: TermTypes.IDisposable[] = [];
     pasteActive: boolean = false;
+    lastUpdated: number;
 
     constructor(
         blockId: string,
@@ -175,6 +176,7 @@ export class TermWrap {
         this.ptyOffset = 0;
         this.dataBytesProcessed = 0;
         this.hasResized = false;
+        this.lastUpdated = Date.now();
         this.terminal = new Terminal(options);
         this.fitAddon = new FitAddon();
         this.fitAddon.noScrollbar = PLATFORM === PlatformMacOS;
@@ -334,6 +336,7 @@ export class TermWrap {
                 this.ptyOffset += data.length;
                 this.dataBytesProcessed += data.length;
             }
+            this.lastUpdated = Date.now();
             resolve();
         });
         return prtn;

frontend/types/gotypes.d.ts

@@ -269,6 +269,20 @@ declare global {
         data: ObjRTInfo;
     };
 
+    // wshrpc.CommandTermGetScrollbackLinesData
+    type CommandTermGetScrollbackLinesData = {
+        linestart: number;
+        lineend: number;
+    };
+
+    // wshrpc.CommandTermGetScrollbackLinesRtnData
+    type CommandTermGetScrollbackLinesRtnData = {
+        totallines: number;
+        linestart: number;
+        lines: string[];
+        lastupdated: number;
+    };
+
     // wshrpc.CommandVarData
     type CommandVarData = {
         key: string;

pkg/aiusechat/tools.go

@@ -180,6 +180,8 @@ func generateToolsForBlock(block *waveobj.Block) []uctypes.ToolDefinition {
 
 	var tools []uctypes.ToolDefinition
 	switch viewType {
+	case "term":
+		tools = append(tools, GetTermGetScrollbackToolDefinition(block))
 	case "web":
 		tools = append(tools, GetWebNavigateToolDefinition(block))
 	case "tsunami":
@@ -253,6 +255,101 @@ func GetWebNavigateToolDefinition(block *waveobj.Block) uctypes.ToolDefinition {
 	}
 }
 
+func GetTermGetScrollbackToolDefinition(block *waveobj.Block) uctypes.ToolDefinition {
+	blockIdPrefix := block.OID[:8]
+	toolName := fmt.Sprintf("term_get_scrollback_%s", blockIdPrefix)
+
+	return uctypes.ToolDefinition{
+		Name:        toolName,
+		DisplayName: fmt.Sprintf("Get Terminal Scrollback %s", blockIdPrefix),
+		Description: fmt.Sprintf("Fetch terminal scrollback from widget %s as plain text. Index 0 is the most recent line; indices increase going upward (older lines).", blockIdPrefix),
+		Strict:      false,
+		InputSchema: map[string]any{
+			"type": "object",
+			"properties": map[string]any{
+				"linestart": map[string]any{
+					"type":        "integer",
+					"minimum":     0,
+					"description": "Logical start index where 0 = most recent line (default: 0)",
+				},
+				"lineend": map[string]any{
+					"type":        "integer",
+					"minimum":     0,
+					"description": "Exclusive end index. Returns lines [linestart, lineend)",
+				},
+				"count": map[string]any{
+					"type":        "integer",
+					"minimum":     1,
+					"description": "Alternative to lineend: number of lines to return from linestart (default: 200)",
+				},
+			},
+			"required":             []string{},
+			"additionalProperties": false,
+		},
+		ToolAnyCallback: func(input any) (any, error) {
+			const DEFAULT_COUNT = 200
+			const MAX_COUNT = 1000
+
+			inputMap := make(map[string]any)
+			if input != nil {
+				var ok bool
+				inputMap, ok = input.(map[string]any)
+				if !ok {
+					return nil, fmt.Errorf("invalid input format")
+				}
+			}
+
+			lineStart := 0
+			if val, ok := inputMap["linestart"].(float64); ok {
+				lineStart = int(val)
+			}
+
+			count := DEFAULT_COUNT
+			if val, ok := inputMap["count"].(float64); ok {
+				count = int(val)
+			} else if lineEndVal, ok := inputMap["lineend"].(float64); ok {
+				lineEnd := int(lineEndVal)
+				count = lineEnd - lineStart
+			}
+
+			count = min(count, MAX_COUNT)
+			if count < 0 {
+				count = 0
+			}
+			lineEnd := lineStart + count
+
+			rpcClient := wshclient.GetBareRpcClient()
+			result, err := wshclient.TermGetScrollbackLinesCommand(
+				rpcClient,
+				wshrpc.CommandTermGetScrollbackLinesData{
+					LineStart: lineStart,
+					LineEnd:   lineEnd,
+				},
+				&wshrpc.RpcOpts{Route: wshutil.MakeFeBlockRouteId(block.OID)},
+			)
+			if err != nil {
+				return nil, fmt.Errorf("failed to get terminal scrollback: %w", err)
+			}
+
+			content := strings.Join(result.Lines, "\n")
+			sinceLastOutputSec := 0
+			if result.LastUpdated > 0 {
+				sinceLastOutputSec = max(0, int((time.Now().UnixMilli()-result.LastUpdated)/1000))
+			}
+
+			return map[string]any{
+				"totallines":            result.TotalLines,
+				"linestart":             result.LineStart,
+				"lineend":               min(lineEnd, result.TotalLines),
+				"returned_lines":        len(result.Lines),
+				"content":               content,
+				"since_last_output_sec": sinceLastOutputSec,
+				"has_more":              lineEnd < result.TotalLines,
+			}, nil
+		},
+	}
+}
+
 func makeTsunamiGetCallback(status *blockcontroller.BlockControllerRuntimeStatus, apiPath string) func(any) (any, error) {
 	return func(input any) (any, error) {
 		if status.TsunamiPort == 0 {

pkg/wshrpc/wshclient/wshclient.go

@@ -535,6 +535,12 @@ func StreamWaveAiCommand(w *wshutil.WshRpc, data wshrpc.WaveAIStreamRequest, opt
 	return sendRpcRequestResponseStreamHelper[wshrpc.WaveAIPacketType](w, "streamwaveai", data, opts)
 }
 
+// command "termgetscrollbacklines", wshserver.TermGetScrollbackLinesCommand
+func TermGetScrollbackLinesCommand(w *wshutil.WshRpc, data wshrpc.CommandTermGetScrollbackLinesData, opts *wshrpc.RpcOpts) (*wshrpc.CommandTermGetScrollbackLinesRtnData, error) {
+	resp, err := sendRpcRequestCallHelper[*wshrpc.CommandTermGetScrollbackLinesRtnData](w, "termgetscrollbacklines", data, opts)
+	return resp, err
+}
+
 // command "test", wshserver.TestCommand
 func TestCommand(w *wshutil.WshRpc, data string, opts *wshrpc.RpcOpts) error {
 	_, err := sendRpcRequestCallHelper[any](w, "test", data, opts)

pkg/wshrpc/wshrpctypes.go

@@ -146,6 +146,8 @@ const (
 
 	Command_GetRTInfo = "getrtinfo"
 	Command_SetRTInfo = "setrtinfo"
+
+	Command_TermGetScrollbackLines = "termgetscrollbacklines"
 )
 
 type RespOrErrorUnion[T any] struct {
@@ -275,6 +277,9 @@ type WshRpcInterface interface {
 	GetRTInfoCommand(ctx context.Context, data CommandGetRTInfoData) (*waveobj.ObjRTInfo, error)
 	SetRTInfoCommand(ctx context.Context, data CommandSetRTInfoData) error
 
+	// terminal
+	TermGetScrollbackLinesCommand(ctx context.Context, data CommandTermGetScrollbackLinesData) (*CommandTermGetScrollbackLinesRtnData, error)
+
 	// proc
 	VDomRenderCommand(ctx context.Context, data vdom.VDomFrontendUpdate) chan RespOrErrorUnion[*vdom.VDomBackendUpdate]
 	VDomUrlRequestCommand(ctx context.Context, data VDomUrlRequestData) chan RespOrErrorUnion[VDomUrlRequestResponse]
@@ -819,3 +824,15 @@ type CommandSetRTInfoData struct {
 	ORef waveobj.ORef   `json:"oref"`
 	Data map[string]any `json:"data" tstype:"ObjRTInfo"`
 }
+
+type CommandTermGetScrollbackLinesData struct {
+	LineStart int `json:"linestart"`
+	LineEnd   int `json:"lineend"`
+}
+
+type CommandTermGetScrollbackLinesRtnData struct {
+	TotalLines  int      `json:"totallines"`
+	LineStart   int      `json:"linestart"`
+	Lines       []string `json:"lines"`
+	LastUpdated int64    `json:"lastupdated"`
+}