save work

.github/workflows/publish.yml

@@ -0,0 +1,23 @@
+name: Publish a new release
+on:
+    release:
+        types: [published]
+jobs:
+    build:
+        runs-on: ubuntu-latest
+        steps:
+            - name: Checkout
+              uses: actions/checkout@v2
+            - name: Get the version
+              id: get_version
+              run: |
+                  VERSION=$(node -e 'console.log(require("./version.js"))')
+                  echo "WAVETERM_VERSION=${VERSION}" >> "$GITHUB_OUTPUT"
+            - name: Copy staged artifacts to the release bucket
+              run: |
+                  . ./buildres/publish-from-staging.sh
+              env:
+                  AWS_ACCESS_KEY_ID: "${{ secrets.S3_USERID }}"
+                  AWS_SECRET_ACCESS_KEY: "${{ secrets.S3_SECRETKEY }}"
+                  AWS_DEFAULT_REGION: us-west-2
+            - name: Publish to Ubuntu PPA

BUILD.md

@@ -53,6 +53,12 @@ Install modules (we use yarn):
 yarn
 ```
 
+Electron also requires specific builds of node_modules to work (because Electron embeds a specific node.js version that might not match your development node.js version). We use a special electron command to cross-compile those modules:
+
+```
+scripthaus run electron-rebuild
+```
+
 ## Running WebPack
 
 We use webpack to build both the React and Electron App Wrapper code. They are both run together using:

README.md

@@ -20,7 +20,7 @@ Wave isn't just another terminal emulator; it's a rethink on how terminals are b
 -   CodeEdit, to edit local and remote files with a VSCode-like inline editor
 -   AI Integration with ChatGPT (or ChatGPT compatible APIs) to help write commands and get answers inline
 
-![WaveTerm Screenshot](./assets/wave-screenshot.png)
+![WaveTerm Screenshot](./assets/wave-screenshot.jpeg)
 
 ## Installation
 

assets/keybindings.json

@@ -3,10 +3,6 @@
       "command": "system:toggleDeveloperTools",
       "keys": ["Cmd:Option:i"]
     },
-    {
-      "command": "system:hideWindow",
-      "keys": ["Cmd:m"]
-    },
     {
       "command": "generic:cancel",
       "keys": ["Escape"]
@@ -36,23 +32,13 @@
       "keys": ["PageDown"]
     },
     {
-      "command": "app:openHistoryView",
+      "command": "app:openHistory",
       "keys": ["Cmd:h"]
     },
     {
       "command": "app:openTabSearchModal",
       "keys": ["Cmd:p"]
     },
-    {
-      "command": "app:openConnectionsView", 
-      "keys": [],
-      "commandStr": "/mainview connections"
-    },
-    {
-      "command": "app:openSettingsView", 
-      "keys": [],
-      "commandStr": "/mainview clientsettings"
-    },
     {
       "command": "app:newTab",
       "keys": ["Cmd:t"]
@@ -131,48 +117,39 @@
     },
     {
       "command": "app:selectWorkspace-1",
-      "keys": ["Cmd:Ctrl:1"],
-      "commandStr": "/session 1"
+      "keys": ["Cmd:Ctrl:1"]
     },
     {
       "command": "app:selectWorkspace-2",
-      "keys": ["Cmd:Ctrl:2"],
-      "commandStr": "/session 2"
+      "keys": ["Cmd:Ctrl:2"]
     },
     {
       "command": "app:selectWorkspace-3",
-      "keys": ["Cmd:Ctrl:3"],
-      "commandStr": "/session 3"
+      "keys": ["Cmd:Ctrl:3"]
     },
     {
       "command": "app:selectWorkspace-4",
-      "keys": ["Cmd:Ctrl:4"],
-      "commandStr": "/session 4"
+      "keys": ["Cmd:Ctrl:4"]
     },
     {
       "command": "app:selectWorkspace-5",
-      "keys": ["Cmd:Ctrl:5"],
-      "commandStr": "/session 5"
+      "keys": ["Cmd:Ctrl:5"]
     },
     {
       "command": "app:selectWorkspace-6",
-      "keys": ["Cmd:Ctrl:6"],
-      "commandStr": "/session 6"
+      "keys": ["Cmd:Ctrl:6"]
     },
     {
       "command": "app:selectWorkspace-7",
-      "keys": ["Cmd:Ctrl:7"],
-      "commandStr": "/session 7"
+      "keys": ["Cmd:Ctrl:7"]
     },
     {
       "command": "app:selectWorkspace-8",
-      "keys": ["Cmd:Ctrl:8"],
-      "commandStr": "/session 8"
+      "keys": ["Cmd:Ctrl:8"]
     },
     {
       "command": "app:selectWorkspace-9",
-      "keys": ["Cmd:Ctrl:9"],
-      "commandStr": "/session 9"
+      "keys": ["Cmd:Ctrl:9"]
     },
     {
       "command": "app:toggleSidebar",
@@ -183,9 +160,8 @@
       "keys": ["Cmd:d"]
     },
     {
-      "command": "app:openBookmarksView",
-      "keys": ["Cmd:b"],
-      "commandStr": "/bookmarks:show"
+      "command": "app:bookmarkActiveLine",
+      "keys": ["Cmd:b"]
     },
     {
       "command": "bookmarks:edit",
@@ -229,8 +205,7 @@
     },
     {
       "command": "cmdinput:openHistory",
-      "keys": ["Ctrl:r"],
-      "commandStr": "/history"
+      "keys": ["Ctrl:r"]
     },
     {
       "command": "cmdinput:openAIChat",

public/themes/default.css

@@ -220,4 +220,6 @@
     --modal-header-bottom-border-color: rgba(241, 246, 243, 0.15);
 
     --logo-button-hover-bg-color: #1e1e1e;
+
+    --xterm-viewport-border-color: rgba(241, 246, 243, 0.15);
 }

public/themes/light.css

@@ -74,4 +74,6 @@
     --toggle-thumb-color: var(--app-bg-color);
 
     --logo-button-hover-bg-color: #f0f0f0;
+
+    --xterm-viewport-border-color: rgba(0, 0, 0, 0.3);
 }

public/themes/term-default.css

@@ -3,7 +3,7 @@
 
 :root {
     /* 
-     * term colors (16 + 6) form the base terminal theme 
+     * term colors (16 + 2) form the base terminal theme 
      * for consistency these colors should be used by plugins/applications
      */
     --term-black: #000000;
@@ -27,6 +27,4 @@
     --term-cmdtext: #ffffff;
     --term-foreground: #d3d7cf;
     --term-background: #000000;
-    --term-selection-background: #ffffff90;
-    --term-cursor-accent: #000000;
 }

public/themes/term-light.css

@@ -6,6 +6,4 @@
     --term-foreground: #000000;
     --term-background: #fefefe;
     --term-cmdtext: #000000;
-    --term-selection-background: #00000040;
-    --term-cursor-accent: #000000;
 }

src/app/bookmarks/bookmarks.tsx

@@ -193,7 +193,7 @@ class BookmarksView extends React.Component<{}, {}> {
         let bookmarks = GlobalModel.bookmarksModel.bookmarks;
         let bookmark: BookmarkType = null;
         return (
-            <MainView className="bookmarks-view" title="Bookmarks" onClose={this.handleClose}>
+            <MainView viewName="bookmarks" title="Bookmarks" onClose={this.handleClose}>
                 <div className="bookmarks-list">
                     <For index="idx" each="bookmark" of={bookmarks}>
                         <Bookmark key={bookmark.bookmarkid} bookmark={bookmark} />

src/app/clientsettings/clientsettings.tsx

@@ -87,7 +87,6 @@ class ClientSettingsView extends React.Component<{ model: RemotesModel }, { hove
         const availableFontFamilies: DropdownItem[] = [];
         availableFontFamilies.push({ label: "JetBrains Mono", value: "JetBrains Mono" });
         availableFontFamilies.push({ label: "Hack", value: "Hack" });
-        availableFontFamilies.push({ label: "Fira Code", value: "Fira Code" });
         return availableFontFamilies;
     }
 

src/app/common/modals/alert.tsx

@@ -44,7 +44,7 @@ class AlertModal extends React.Component<{}, {}> {
                         <Markdown text={message?.message ?? ""} extraClassName="bottom-margin" />
                     </If>
                     <If condition={!message?.markdown}>{message?.message}</If>
-                    <If condition={message?.confirmflag}>
+                    <If condition={message.confirmflag}>
                         <Checkbox
                             onChange={this.handleDontShowAgain}
                             label={"Don't show me this again"}

src/app/common/modals/viewremoteconndetail.less

@@ -90,12 +90,25 @@
                     margin-top: 5px;
                     overflow-x: auto;
                     overflow-y: hidden;
-                    border: 1px solid var(--app-border-color);
-                    border-radius: 6px;
-                    padding: 6px 10px;
 
                     .terminal-connectelem {
                         height: 163px !important; // Needed to override plugin height
+
+                        .xterm-viewport {
+                            display: flex;
+                            padding: 6px 10px;
+                            gap: 8px;
+                            align-items: flex-start;
+                            align-self: stretch;
+                            border-radius: 6px;
+                            border: 1px solid var(--xterm-viewport-border-color);
+                            background: #080a08;
+                            height: 163px !important; // Needed to override plugin height
+                        }
+
+                        .xterm-screen {
+                            padding: 10px;
+                        }
                     }
                 }
             }

src/app/line/renderer/basicrenderer.tsx

@@ -0,0 +1,276 @@
+// Copyright 2023, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import * as React from "react";
+import * as mobxReact from "mobx-react";
+import * as mobx from "mobx";
+
+import { debounce } from "throttle-debounce";
+import * as util from "@/util/util";
+import { GlobalModel } from "@/models";
+
+class SimpleBlobRendererModel {
+    context: RendererContext;
+    opts: RendererOpts;
+    isDone: OV<boolean>;
+    api: RendererModelContainerApi;
+    savedHeight: number;
+    loading: OV<boolean>;
+    loadError: OV<string> = mobx.observable.box(null, {
+        name: "renderer-loadError",
+    });
+    lineState: LineStateType;
+    ptyData: PtyDataType;
+    ptyDataSource: (termContext: TermContextUnion) => Promise<PtyDataType>;
+    dataBlob: Blob;
+    readOnly: boolean;
+    notFound: boolean;
+
+    initialize(params: RendererModelInitializeParams): void {
+        this.loading = mobx.observable.box(true, { name: "renderer-loading" });
+        this.isDone = mobx.observable.box(params.isDone, {
+            name: "renderer-isDone",
+        });
+        this.context = params.context;
+        this.opts = params.opts;
+        this.api = params.api;
+        this.lineState = params.lineState;
+        this.savedHeight = params.savedHeight;
+        this.ptyDataSource = params.ptyDataSource;
+        if (this.isDone.get()) {
+            setTimeout(() => this.reload(0), 10);
+        }
+    }
+
+    dispose(): void {
+        return;
+    }
+
+    giveFocus(): void {
+        return;
+    }
+
+    updateOpts(update: RendererOptsUpdate): void {
+        Object.assign(this.opts, update);
+    }
+
+    updateHeight(newHeight: number): void {
+        if (this.savedHeight != newHeight) {
+            this.savedHeight = newHeight;
+            this.api.saveHeight(newHeight);
+        }
+    }
+
+    setIsDone(): void {
+        if (this.isDone.get()) {
+            return;
+        }
+        mobx.action(() => {
+            this.isDone.set(true);
+        })();
+        this.reload(0);
+    }
+
+    reload(delayMs: number): void {
+        mobx.action(() => {
+            this.loading.set(true);
+        })();
+        if (delayMs == 0) {
+            this.reload_noDelay();
+        } else {
+            setTimeout(() => {
+                this.reload_noDelay();
+            }, delayMs);
+        }
+    }
+
+    reload_noDelay(): void {
+        let source = this.lineState["prompt:source"] || "pty";
+        if (source == "pty") {
+            this.reloadPtyData();
+        } else if (source == "file") {
+            this.reloadFileData();
+        } else {
+            mobx.action(() => {
+                this.loadError.set("error: invalid load source: " + source);
+            })();
+        }
+    }
+
+    reloadFileData(): void {
+        // todo add file methods to API, so we don't have a GlobalModel dependency here!
+        let path = this.lineState["prompt:file"];
+        if (util.isBlank(path)) {
+            mobx.action(() => {
+                this.loadError.set("renderer has file source, but no prompt:file specified");
+            })();
+            return;
+        }
+        let rtnp = GlobalModel.readRemoteFile(this.context.screenId, this.context.lineId, path);
+        rtnp.then((file) => {
+            this.notFound = (file as any).notFound;
+            this.readOnly = (file as any).readOnly;
+            this.dataBlob = file;
+            mobx.action(() => {
+                this.loading.set(false);
+                this.loadError.set(null);
+            })();
+        }).catch((e) => {
+            mobx.action(() => {
+                this.loadError.set("error loading file data: " + e);
+            })();
+        });
+    }
+
+    reloadPtyData(): void {
+        this.readOnly = true;
+        let rtnp = this.ptyDataSource(this.context);
+        if (rtnp == null) {
+            console.log("no promise returned from ptyDataSource (simplerenderer)", this.context);
+            return;
+        }
+        rtnp.then((ptydata) => {
+            this.ptyData = ptydata;
+            this.dataBlob = new Blob([this.ptyData.data]);
+            mobx.action(() => {
+                this.loading.set(false);
+                this.loadError.set(null);
+            })();
+        }).catch((e) => {
+            mobx.action(() => {
+                this.loadError.set("error loading data: " + e);
+            })();
+        });
+    }
+
+    receiveData(pos: number, data: Uint8Array, reason?: string): void {
+        // this.dataBuf.receiveData(pos, data, reason);
+    }
+}
+
+@mobxReact.observer
+class SimpleBlobRenderer extends React.Component<
+    {
+        rendererContainer: RendererContainerType;
+        lineId: string;
+        plugin: RendererPluginType;
+        onHeightChange: () => void;
+        initParams: RendererModelInitializeParams;
+        scrollToBringIntoViewport: () => void;
+        isSelected: boolean;
+        shouldFocus: boolean;
+    },
+    {}
+> {
+    model: SimpleBlobRendererModel;
+    wrapperDivRef: React.RefObject<any> = React.createRef();
+    rszObs: ResizeObserver;
+    updateHeight_debounced: (newHeight: number) => void;
+
+    constructor(props: any) {
+        super(props);
+        let { rendererContainer, lineId, plugin, initParams } = this.props;
+        this.model = new SimpleBlobRendererModel();
+        this.model.initialize(initParams);
+        rendererContainer.registerRenderer(lineId, this.model);
+        this.updateHeight_debounced = debounce(1000, this.updateHeight.bind(this));
+    }
+
+    updateHeight(newHeight: number): void {
+        this.model.updateHeight(newHeight);
+    }
+
+    handleResize(entries: ResizeObserverEntry[]): void {
+        if (this.model.loading.get()) {
+            return;
+        }
+        if (this.props.onHeightChange) {
+            this.props.onHeightChange();
+        }
+        if (!this.model.loading.get() && this.wrapperDivRef.current != null) {
+            let height = this.wrapperDivRef.current.offsetHeight;
+            this.updateHeight_debounced(height);
+        }
+    }
+
+    checkRszObs() {
+        if (this.rszObs != null) {
+            return;
+        }
+        if (this.wrapperDivRef.current == null) {
+            return;
+        }
+        this.rszObs = new ResizeObserver(this.handleResize.bind(this));
+        this.rszObs.observe(this.wrapperDivRef.current);
+    }
+
+    componentDidMount() {
+        this.checkRszObs();
+    }
+
+    componentWillUnmount() {
+        let { rendererContainer, lineId } = this.props;
+        rendererContainer.unloadRenderer(lineId);
+        if (this.rszObs != null) {
+            this.rszObs.disconnect();
+            this.rszObs = null;
+        }
+    }
+
+    componentDidUpdate() {
+        this.checkRszObs();
+    }
+
+    render() {
+        let { plugin } = this.props;
+        let model = this.model;
+        if (model.loadError.get() != null) {
+            let errorText = model.loadError.get();
+            let height = this.model.savedHeight;
+            return (
+                <div ref={this.wrapperDivRef} style={{ minHeight: height, fontSize: model.opts.termFontSize }}>
+                    <div className="load-error-text">ERROR: {errorText}</div>
+                </div>
+            );
+        }
+        if (model.loading.get()) {
+            let height = this.model.savedHeight;
+            return (
+                <div
+                    ref={this.wrapperDivRef}
+                    className="renderer-loading"
+                    style={{ minHeight: height, fontSize: model.opts.termFontSize }}
+                >
+                    loading content <i className="fa fa-ellipsis fa-fade" />
+                </div>
+            );
+        }
+        let Comp = plugin.simpleComponent;
+        if (Comp == null) {
+            <div ref={this.wrapperDivRef}>(no component found in plugin)</div>;
+        }
+        let { festate, cmdstr, exitcode } = this.props.initParams.rawCmd;
+        return (
+            <div ref={this.wrapperDivRef} className="sr-wrapper">
+                <Comp
+                    cwd={festate.cwd}
+                    cmdstr={cmdstr}
+                    exitcode={exitcode}
+                    data={model.dataBlob as ExtBlob}
+                    readOnly={model.readOnly}
+                    notFound={model.notFound}
+                    lineState={model.lineState}
+                    context={model.context}
+                    opts={model.opts}
+                    savedHeight={model.savedHeight}
+                    scrollToBringIntoViewport={this.props.scrollToBringIntoViewport}
+                    isSelected={this.props.isSelected}
+                    shouldFocus={this.props.shouldFocus}
+                    rendererApi={model.api}
+                />
+            </div>
+        );
+    }
+}
+
+export { SimpleBlobRendererModel, SimpleBlobRenderer };

src/electron/emain.ts

@@ -263,12 +263,7 @@ const menuTemplate: Electron.MenuItemConstructorOptions[] = [
             { type: "separator" },
             { role: "services" },
             { type: "separator" },
-            {
-                label: "Hide",
-                click: () => {
-                    app.hide();
-                },
-            },
+            { role: "hide" },
             { role: "hideOthers" },
             { type: "separator" },
             { role: "quit" },
@@ -308,21 +303,16 @@ function shFrameNavHandler(event: Electron.Event<Electron.WebContentsWillFrameNa
         // only use this handler to process iframe events (non-iframe events go to shNavHandler)
         return;
     }
+    event.preventDefault();
     const url = event.url;
     console.log(`frame-navigation url=${url} frame=${event.frame.name}`);
     if (event.frame.name == "webview") {
         // "webview" links always open in new window
         // this will *not* effect the initial load because srcdoc does not count as an electron navigation
         console.log("open external, frameNav", url);
-        event.preventDefault();
         electron.shell.openExternal(url);
         return;
     }
-    if (event.frame.name == "pdfview" && url.startsWith("blob:file:///")) {
-        // allowed
-        return;
-    }
-    event.preventDefault();
     console.log("frame navigation canceled");
 }
 
@@ -365,6 +355,13 @@ function createMainWindow(clientData: ClientDataType | null): Electron.BrowserWi
             e.preventDefault();
             return;
         }
+        if (checkKeyPressed(waveEvent, "Cmd:i")) {
+            e.preventDefault();
+            if (!input.alt) {
+                win.webContents.send("i-cmd", mods);
+            }
+            return;
+        }
         if (checkKeyPressed(waveEvent, "Cmd:r")) {
             e.preventDefault();
             win.webContents.send("r-cmd", mods);
@@ -380,6 +377,16 @@ function createMainWindow(clientData: ClientDataType | null): Electron.BrowserWi
             win.webContents.send("w-cmd", mods);
             return;
         }
+        if (checkKeyPressed(waveEvent, "Cmd:h")) {
+            win.webContents.send("h-cmd", mods);
+            e.preventDefault();
+            return;
+        }
+        if (checkKeyPressed(waveEvent, "Cmd:p")) {
+            win.webContents.send("p-cmd", mods);
+            e.preventDefault();
+            return;
+        }
         if (checkKeyPressed(waveEvent, "Cmd:ArrowUp") || checkKeyPressed(waveEvent, "Cmd:ArrowDown")) {
             if (checkKeyPressed(waveEvent, "Cmd:ArrowUp")) {
                 win.webContents.send("meta-arrowup");
@@ -398,7 +405,7 @@ function createMainWindow(clientData: ClientDataType | null): Electron.BrowserWi
             e.preventDefault();
             return;
         }
-        if (input.code.startsWith("Digit") && input.meta && !input.control) {
+        if (input.code.startsWith("Digit") && input.meta) {
             const digitNum = parseInt(input.code.substring(5));
             if (isNaN(digitNum) || digitNum < 1 || digitNum > 9) {
                 return;
@@ -523,13 +530,6 @@ electron.ipcMain.on("toggle-developer-tools", (event) => {
     event.returnValue = true;
 });
 
-electron.ipcMain.on("hide-window", (event) => {
-    if (MainWindow != null) {
-        MainWindow.hide();
-    }
-    event.returnValue = true;
-});
-
 electron.ipcMain.on("get-id", (event) => {
     event.returnValue = instanceId + ":" + event.processId;
 });

src/electron/preload.js

@@ -1,7 +1,6 @@
 let { contextBridge, ipcRenderer } = require("electron");
 
 contextBridge.exposeInMainWorld("api", {
-    hideWindow: () => ipc.Renderer.send("hide-window"),
     toggleDeveloperTools: () => ipcRenderer.send("toggle-developer-tools"),
     getId: () => ipcRenderer.sendSync("get-id"),
     getPlatform: () => ipcRenderer.sendSync("get-platform"),
@@ -22,8 +21,11 @@ contextBridge.exposeInMainWorld("api", {
     getAppUpdateStatus: () => ipcRenderer.sendSync("get-app-update-status"),
     onAppUpdateStatus: (callback) => ipcRenderer.on("app-update-status", (_, val) => callback(val)),
     onTCmd: (callback) => ipcRenderer.on("t-cmd", callback),
+    onICmd: (callback) => ipcRenderer.on("i-cmd", callback),
     onLCmd: (callback) => ipcRenderer.on("l-cmd", callback),
+    onHCmd: (callback) => ipcRenderer.on("h-cmd", callback),
     onWCmd: (callback) => ipcRenderer.on("w-cmd", callback),
+    onPCmd: (callback) => ipcRenderer.on("p-cmd", callback),
     onRCmd: (callback) => ipcRenderer.on("r-cmd", callback),
     onZoomChanged: (callback) => ipcRenderer.on("zoom-changed", callback),
     onMetaArrowUp: (callback) => ipcRenderer.on("meta-arrowup", callback),

src/models/bookmarks.ts

@@ -206,7 +206,7 @@ class BookmarksModel {
     }
 
     handleDocKeyDown(e: any): void {
-        const waveEvent = adaptFromReactOrNativeKeyEvent(e);
+        let waveEvent = adaptFromReactOrNativeKeyEvent(e);
         if (checkKeyPressed(waveEvent, "Escape")) {
             e.preventDefault();
             if (this.editingBookmark.get() != null) {