switch /wave/stream-file to use new modern streams (w/ flow control) and fix big ttfb streaming bug (#3084)

Author: sawka

frontend/app/store/wshclientapi.ts

@@ -378,6 +378,12 @@ export class RpcApiType {
         return client.wshRpcCall("filerestorebackup", data, opts);
     }
 
+    // command "filestream" [call]
+    FileStreamCommand(client: WshClient, data: CommandFileStreamData, opts?: RpcOpts): Promise<FileInfo> {
+        if (this.mockClient) return this.mockClient.mockWshRpcCall(client, "filestream", data, opts);
+        return client.wshRpcCall("filestream", data, opts);
+    }
+
     // command "filewrite" [call]
     FileWriteCommand(client: WshClient, data: FileData, opts?: RpcOpts): Promise<void> {
         if (this.mockClient) return this.mockClient.mockWshRpcCall(client, "filewrite", data, opts);
@@ -720,6 +726,12 @@ export class RpcApiType {
         return client.wshRpcCall("remotefilemultiinfo", data, opts);
     }
 
+    // command "remotefilestream" [call]
+    RemoteFileStreamCommand(client: WshClient, data: CommandRemoteFileStreamData, opts?: RpcOpts): Promise<FileInfo> {
+        if (this.mockClient) return this.mockClient.mockWshRpcCall(client, "remotefilestream", data, opts);
+        return client.wshRpcCall("remotefilestream", data, opts);
+    }
+
     // command "remotefiletouch" [call]
     RemoteFileTouchCommand(client: WshClient, data: string, opts?: RpcOpts): Promise<void> {
         if (this.mockClient) return this.mockClient.mockWshRpcCall(client, "remotefiletouch", data, opts);

frontend/app/view/preview/preview-streaming.tsx

@@ -72,18 +72,14 @@ function StreamingPreview({ model }: SpecializedViewProps) {
     if (fileInfo.mimetype.startsWith("video/")) {
         return (
             <div className="flex flex-row h-full overflow-hidden items-center justify-center">
-                <video controls className="w-full h-full p-[10px] object-contain">
-                    <source src={streamingUrl} />
-                </video>
+                <video controls src={streamingUrl} className="w-full h-full p-[10px] object-contain" />
             </div>
         );
     }
     if (fileInfo.mimetype.startsWith("audio/")) {
         return (
             <div className="flex flex-row h-full overflow-hidden items-center justify-center">
-                <audio controls className="w-full h-full p-[10px] object-contain">
-                    <source src={streamingUrl} />
-                </audio>
+                <audio controls src={streamingUrl} className="w-full h-full p-[10px] object-contain" />
             </div>
         );
     }

frontend/app/view/term/termwrap.ts

@@ -531,7 +531,7 @@ export class TermWrap {
             }
         }
         let resolve: () => void = null;
-        let prtn = new Promise<void>((presolve, _) => {
+        const prtn = new Promise<void>((presolve, _) => {
             resolve = presolve;
         });
         this.terminal.write(data, () => {

frontend/types/gotypes.d.ts

@@ -380,6 +380,13 @@ declare global {
         restoretofilename: string;
     };
 
+    // wshrpc.CommandFileStreamData
+    type CommandFileStreamData = {
+        info: FileInfo;
+        byterange?: string;
+        streammeta: StreamMeta;
+    };
+
     // wshrpc.CommandGetMetaData
     type CommandGetMetaData = {
         oref: ORef;
@@ -521,6 +528,13 @@ declare global {
         paths: string[];
     };
 
+    // wshrpc.CommandRemoteFileStreamData
+    type CommandRemoteFileStreamData = {
+        path: string;
+        byterange?: string;
+        streammeta: StreamMeta;
+    };
+
     // wshrpc.CommandRemoteListEntriesData
     type CommandRemoteListEntriesData = {
         path: string;

pkg/remote/fileshare/wshfs/wshfs.go

@@ -61,12 +61,37 @@ func ReadStream(ctx context.Context, data wshrpc.FileData) <-chan wshrpc.RespOrE
 func readStream(conn *connparse.Connection, data wshrpc.FileData) <-chan wshrpc.RespOrErrorUnion[wshrpc.FileData] {
 	byteRange := ""
 	if data.At != nil && data.At.Size > 0 {
-		byteRange = fmt.Sprintf("%d-%d", data.At.Offset, data.At.Offset+int64(data.At.Size))
+		byteRange = fmt.Sprintf("%d-%d", data.At.Offset, data.At.Offset+int64(data.At.Size)-1)
 	}
 	streamFileData := wshrpc.CommandRemoteStreamFileData{Path: conn.Path, ByteRange: byteRange}
 	return wshclient.RemoteStreamFileCommand(RpcClient, streamFileData, &wshrpc.RpcOpts{Route: wshutil.MakeConnectionRouteId(conn.Host)})
 }
 
+func GetConnectionRouteId(ctx context.Context, path string) (string, error) {
+	conn, err := parseConnection(ctx, path)
+	if err != nil {
+		return "", err
+	}
+	return wshutil.MakeConnectionRouteId(conn.Host), nil
+}
+
+func FileStream(ctx context.Context, data wshrpc.CommandFileStreamData) (*wshrpc.FileInfo, error) {
+	if data.Info == nil {
+		return nil, fmt.Errorf("file info is required")
+	}
+	log.Printf("FileStream: %v", data.Info.Path)
+	conn, err := parseConnection(ctx, data.Info.Path)
+	if err != nil {
+		return nil, err
+	}
+	remoteData := wshrpc.CommandRemoteFileStreamData{
+		Path:       conn.Path,
+		ByteRange:  data.ByteRange,
+		StreamMeta: data.StreamMeta,
+	}
+	return wshclient.RemoteFileStreamCommand(RpcClient, remoteData, &wshrpc.RpcOpts{Route: wshutil.MakeConnectionRouteId(conn.Host)})
+}
+
 func ListEntries(ctx context.Context, path string, opts *wshrpc.FileListOpts) ([]*wshrpc.FileInfo, error) {
 	log.Printf("ListEntries: %v", path)
 	conn, err := parseConnection(ctx, path)

pkg/util/fileutil/fileutil.go

@@ -1,10 +1,11 @@
-// Copyright 2025, Command Line Inc.
+// Copyright 2026, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
 package fileutil
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"io"
 	"io/fs"
@@ -18,6 +19,38 @@ import (
 	"github.com/wavetermdev/waveterm/pkg/wavebase"
 )
 
+type ByteRangeType struct {
+	All     bool
+	Start   int64
+	End     int64 // inclusive; only valid when OpenEnd is false
+	OpenEnd bool  // true when range is "N-" (read from Start to EOF)
+}
+
+func ParseByteRange(rangeStr string) (ByteRangeType, error) {
+	if rangeStr == "" {
+		return ByteRangeType{All: true}, nil
+	}
+	// handle open-ended range "N-"
+	if len(rangeStr) > 0 && rangeStr[len(rangeStr)-1] == '-' {
+		var start int64
+		_, err := fmt.Sscanf(rangeStr, "%d-", &start)
+		if err != nil || start < 0 {
+			return ByteRangeType{}, errors.New("invalid byte range")
+		}
+		return ByteRangeType{Start: start, OpenEnd: true}, nil
+	}
+	var start, end int64
+	_, err := fmt.Sscanf(rangeStr, "%d-%d", &start, &end)
+	if err != nil {
+		return ByteRangeType{}, errors.New("invalid byte range")
+	}
+	if start < 0 || end < 0 || start > end {
+		return ByteRangeType{}, errors.New("invalid byte range")
+	}
+	// End is inclusive (HTTP byte range semantics: bytes=0-999 means 1000 bytes)
+	return ByteRangeType{Start: start, End: end}, nil
+}
+
 func FixPath(path string) (string, error) {
 	origPath := path
 	var err error