test using exec property

.github/workflows/build-helper.yml

@@ -27,7 +27,7 @@ jobs:
               if: matrix.platform == 'linux'
               run: |
                   sudo apt-get update
-                  sudo apt-get install --no-install-recommends -y libarchive-tools libopenjp2-tools rpm
+                  sudo apt-get install --no-install-recommends -y libarchive-tools libopenjp2-tools rpm snapcraft snapd
             - uses: actions/setup-go@v5
               with:
                   go-version: ${{env.GO_VERSION}}

assets/default-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,7 +32,7 @@
       "keys": ["PageDown"]
     },
     {
-      "command": "app:openHistoryView",
+      "command": "app:openHistory",
       "keys": ["Cmd:h"]
     },
     {
@@ -45,13 +41,11 @@
     },
     {
       "command": "app:openConnectionsView", 
-      "keys": [],
-      "commandStr": "/mainview connections"
+      "keys": []
     },
     {
       "command": "app:openSettingsView", 
-      "keys": [],
-      "commandStr": "/mainview clientsettings"
+      "keys": []
     },
     {
       "command": "app:newTab",
@@ -131,48 +125,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 +168,8 @@
       "keys": ["Cmd:d"]
     },
     {
-      "command": "app:openBookmarksView",
-      "keys": ["Cmd:b"],
-      "commandStr": "/bookmarks:show"
+      "command": "app:bookmarkActiveLine",
+      "keys": ["Cmd:b"]
     },
     {
       "command": "bookmarks:edit",
@@ -229,8 +213,7 @@
     },
     {
       "command": "cmdinput:openHistory",
-      "keys": ["Ctrl:r"],
-      "commandStr": "/history"
+      "keys": ["Ctrl:r"]
     },
     {
       "command": "cmdinput:openAIChat",

electron-builder.config.js

@@ -56,6 +56,7 @@ const config = {
                 arch: "universal",
             },
         ],
+        appId: "dev.commandline.waveterm",
         icon: "public/waveterm.icns",
         category: "public.app-category.developer-tools",
         minimumSystemVersion: "10.15.0",
@@ -70,10 +71,11 @@ const config = {
             .map((f) => path.resolve(f.path, f.name)),
     },
     linux: {
+        appId: "dev.commandline.waveterm",
         executableName: pkg.productName,
         category: "TerminalEmulator",
         icon: "public/waveterm.icns",
-        target: ["zip", "deb", "rpm", "AppImage", "pacman"],
+        target: ["zip", "deb", "rpm", "AppImage", "pacman", "snap"],
         synopsis: pkg.description,
         description: null,
         desktop: {
@@ -86,6 +88,23 @@ const config = {
     appImage: {
         license: "LICENSE",
     },
+    snap: {
+        base: "core20",
+        grade: "stable",
+        confinement: "classic",
+        summary: pkg.productName,
+        title: pkg.productName,
+        description: null,
+        synopsis: pkg.description,
+        allowNativeWayland: true,
+        desktop: {
+            Name: pkg.productName,
+            Comment: pkg.description,
+            Keywords: "developer;terminal;emulator;",
+            category: "Development;Utility;",
+            exec: pkg.productName,
+        },
+    },
     publish: {
         provider: "generic",
         url: "https://dl.waveterm.dev/releases",

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" },
@@ -518,13 +513,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"),

src/models/model.ts

@@ -143,7 +143,7 @@ class Model {
             this.runUpdate(message, interactive);
         });
         this.ws.reconnect();
-        this.keybindManager = new KeybindManager(this);
+        this.keybindManager = new KeybindManager();
         this.readConfigKeybindings();
         this.initSystemKeybindings();
         this.initAppKeybindings();
@@ -222,31 +222,46 @@ class Model {
             getApi().toggleDeveloperTools();
             return true;
         });
-        this.keybindManager.registerKeybinding("system", "electron", "system:minimizeWindow", (waveEvent) => {
-            getApi().hideWindow();
-            return true;
-        });
     }
 
     initAppKeybindings() {
         for (let index = 1; index <= 9; index++) {
-            this.keybindManager.registerKeybinding("app", "model", "app:selectWorkspace-" + index, null);
+            this.keybindManager.registerKeybinding("app", "model", "app:selectWorkspace-" + index, (waveEvent) => {
+                this.onSwitchSessionCmd(index);
+                return true;
+            });
         }
+
         this.keybindManager.registerKeybinding("app", "model", "app:focusCmdInput", (waveEvent) => {
+            console.log("focus cmd input callback");
             this.onFocusCmdInputPressed();
             return true;
         });
-        this.keybindManager.registerKeybinding("app", "model", "app:openBookmarksView", null);
-        this.keybindManager.registerKeybinding("app", "model", "app:openHistoryView", (waveEvent) => {
+
+        this.keybindManager.registerKeybinding("app", "model", "app:bookmarkActiveLine", (waveEvent) => {
+            this.onBookmarkViewPressed();
+            return true;
+        });
+
+        this.keybindManager.registerKeybinding("app", "model", "app:openHistory", (waveEvent) => {
             this.onOpenHistoryPressed();
             return true;
         });
+
         this.keybindManager.registerKeybinding("app", "model", "app:openTabSearchModal", (waveEvent) => {
             this.onOpenTabSearchModalPressed();
             return true;
         });
-        this.keybindManager.registerKeybinding("app", "model", "app:openConnectionsView", null);
-        this.keybindManager.registerKeybinding("app", "model", "app:openSettingsView", null);
+
+        this.keybindManager.registerKeybinding("app", "model", "app:openConnectionsView", (waveEvent) => {
+            this.onOpenConnectionsViewPressed();
+            return true;
+        });
+
+        this.keybindManager.registerKeybinding("app", "model", "app:openSettingsView", (waveEvent) => {
+            this.onOpenSettingsViewPressed();
+            return true;
+        });
     }
 
     static getInstance(): Model {
@@ -1008,12 +1023,6 @@ class Model {
                                 console.warn("invalid bookmarksview in update:", update.mainview);
                             }
                             break;
-                        case "clientsettings":
-                            this.activeMainView.set("clientsettings");
-                            break;
-                        case "connections":
-                            this.activeMainView.set("connections");
-                            break;
                         case "plugins":
                             this.pluginsModel.showPluginsView();
                             break;

src/types/custom.d.ts

@@ -880,7 +880,6 @@ declare global {
     };
 
     type ElectronApi = {
-        hideWindow: () => void;
         toggleDeveloperTools: () => void;
         getId: () => string;
         getIsDev: () => boolean;

src/util/keyutil.ts

@@ -4,7 +4,7 @@ import * as electron from "electron";
 import { parse } from "node:path";
 import { v4 as uuidv4 } from "uuid";
 import defaultKeybindingsFile from "../../assets/default-keybindings.json";
-const defaultKeybindings: KeybindConfigArray = defaultKeybindingsFile;
+const defaultKeybindings: KeybindConfig = defaultKeybindingsFile;
 
 type KeyPressDecl = {
     mods: {
@@ -24,18 +24,12 @@ const KeyTypeKey = "key";
 const KeyTypeCode = "code";
 
 type KeybindCallback = (event: WaveKeyboardEvent) => boolean;
-type KeybindConfigArray = Array<KeybindConfig>;
-type KeybindConfig = { command: string; keys: Array<string>; commandStr?: string };
-
-const Callback = "callback";
-const Command = "command";
+type KeybindConfig = Array<{ command: string; keys: Array<string> }>;
 
 type Keybind = {
     domain: string;
     keybinding: string;
-    action: string;
     callback: KeybindCallback;
-    commandStr: string;
 };
 
 const KeybindLevels = ["system", "modal", "app", "pane", "plugin"];
@@ -44,12 +38,11 @@ class KeybindManager {
     domainCallbacks: Map<string, KeybindCallback>;
     levelMap: Map<string, Array<Keybind>>;
     levelArray: Array<string>;
-    keyDescriptionsMap: Map<string, KeybindConfig>;
-    userKeybindings: KeybindConfigArray;
+    keyDescriptionsMap: Map<string, Array<string>>;
+    userKeybindings: KeybindConfig;
     userKeybindingError: OV<string>;
-    globalModel: any;
 
-    constructor(GlobalModel: any) {
+    constructor() {
         this.levelMap = new Map();
         this.domainCallbacks = new Map();
         this.levelArray = KeybindLevels;
@@ -60,7 +53,6 @@ class KeybindManager {
         this.userKeybindingError = mobx.observable.box(null, {
             name: "keyutil-userKeybindingError",
         });
-        this.globalModel = GlobalModel;
         this.initKeyDescriptionsMap();
     }
 
@@ -71,7 +63,7 @@ class KeybindManager {
         let newKeyDescriptions = new Map();
         for (let index = 0; index < defaultKeybindings.length; index++) {
             let curKeybind = defaultKeybindings[index];
-            newKeyDescriptions.set(curKeybind.command, curKeybind);
+            newKeyDescriptions.set(curKeybind.command, curKeybind.keys);
         }
         let curUserCommand = "";
         if (this.userKeybindings != null && this.userKeybindings instanceof Array) {
@@ -93,15 +85,7 @@ class KeybindManager {
                             throw new Error("invalid keybind key");
                         }
                     }
-                    let defaultCmd = this.keyDescriptionsMap.get(curKeybind.command);
-                    if (
-                        defaultCmd != null &&
-                        defaultCmd.commandStr != null &&
-                        (curKeybind.commandStr == null || curKeybind.commandStr == "")
-                    ) {
-                        curKeybind.commandStr = this.keyDescriptionsMap.get(curKeybind.command).commandStr;
-                    }
-                    newKeyDescriptions.set(curKeybind.command, curKeybind);
+                    newKeyDescriptions.set(curKeybind.command, curKeybind.keys);
                 }
             } catch (e) {
                 let userError = `${curUserCommand} is invalid: error: ${e}`;
@@ -114,48 +98,16 @@ class KeybindManager {
         this.keyDescriptionsMap = newKeyDescriptions;
     }
 
-    runSlashCommand(curKeybind: Keybind): boolean {
-        let curConfigKeybind = this.keyDescriptionsMap.get(curKeybind.keybinding);
-        if (curConfigKeybind == null || curConfigKeybind.commandStr == null || curKeybind.commandStr == "") {
-            return false;
-        }
-        let commandsList = curConfigKeybind.commandStr.trim().split(";");
-        this.runIndividualSlashCommand(commandsList);
-        return true;
-    }
-
-    runIndividualSlashCommand(commandsList: Array<string>): boolean {
-        if (commandsList.length == 0) {
-            return true;
-        }
-        let curCommand = commandsList.shift();
-        console.log("running: ", curCommand);
-        let prtn = this.globalModel.submitRawCommand(curCommand, false, false);
-        prtn.then((rtn) => {
-            if (!rtn.success) {
-                console.log("error running command ", curCommand);
-                return false;
-            }
-            return this.runIndividualSlashCommand(commandsList);
-        }).catch((error) => {
-            console.log("caught error running command ", curCommand, ": ", error);
-            return false;
-        });
-    }
-
     processLevel(nativeEvent: any, event: WaveKeyboardEvent, keybindsArray: Array<Keybind>): boolean {
         // iterate through keybinds in backwards order
         for (let index = keybindsArray.length - 1; index >= 0; index--) {
             let curKeybind = keybindsArray[index];
             if (this.checkKeyPressed(event, curKeybind.keybinding)) {
                 let shouldReturn = false;
-                let shouldRunCommand = true;
                 if (curKeybind.callback != null) {
                     shouldReturn = curKeybind.callback(event);
-                    shouldRunCommand = false;
                 }
                 if (!shouldReturn && this.domainCallbacks.has(curKeybind.domain)) {
-                    shouldRunCommand = false;
                     let curDomainCallback = this.domainCallbacks.get(curKeybind.domain);
                     if (curDomainCallback != null) {
                         shouldReturn = curDomainCallback(event);
@@ -163,9 +115,6 @@ class KeybindManager {
                         console.log("domain callback for ", curKeybind.domain, " is null. This should never happen");
                     }
                 }
-                if (shouldRunCommand) {
-                    shouldReturn = this.runSlashCommand(curKeybind);
-                }
                 if (shouldReturn) {
                     nativeEvent.preventDefault();
                     nativeEvent.stopPropagation();
@@ -320,7 +269,7 @@ class KeybindManager {
         if (!this.keyDescriptionsMap.has(keyDescription)) {
             return false;
         }
-        let keyPressArray = this.keyDescriptionsMap.get(keyDescription).keys;
+        let keyPressArray = this.keyDescriptionsMap.get(keyDescription);
         for (let index = 0; index < keyPressArray.length; index++) {
             let curKeyPress = keyPressArray[index];
             let pressed = checkKeyPressed(event, curKeyPress);

wavesrv/pkg/cmdrunner/cmdrunner.go

@@ -171,9 +171,6 @@ func init() {
 	registerCmdFn("reset:cwd", ResetCwdCommand)
 	registerCmdFn("signal", SignalCommand)
 	registerCmdFn("sync", SyncCommand)
-	registerCmdFn("sleep", SleepCommand)
-
-	registerCmdFn("mainview", MainViewCommand)
 
 	registerCmdFn("session", SessionCommand)
 	registerCmdFn("session:open", SessionOpenCommand)
@@ -3563,46 +3560,6 @@ func SessionSetCommand(ctx context.Context, pk *scpacket.FeCommandPacketType) (s
 	return update, nil
 }
 
-func SleepCommand(ctx context.Context, pk *scpacket.FeCommandPacketType) (scbus.UpdatePacket, error) {
-	sleepTimeLimit := 10000
-	if len(pk.Args) < 1 {
-		return nil, fmt.Errorf("no argument found - usage: /sleep [ms]")
-	}
-	sleepArg := pk.Args[0]
-	sleepArgInt, err := strconv.Atoi(sleepArg)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't parse sleep arg: %v", err)
-	}
-	if sleepArgInt > sleepTimeLimit {
-		return nil, fmt.Errorf("sleep arg is too long, max value is %v", sleepTimeLimit)
-	}
-	time.Sleep(time.Duration(sleepArgInt) * time.Millisecond)
-	update := scbus.MakeUpdatePacket()
-	return update, nil
-}
-
-func MainViewCommand(ctx context.Context, pk *scpacket.FeCommandPacketType) (scbus.UpdatePacket, error) {
-	if len(pk.Args) < 1 {
-		return nil, fmt.Errorf("no argument found - usage: /mainview [view]")
-	}
-	update := scbus.MakeUpdatePacket()
-	mainViewArg := pk.Args[0]
-	if mainViewArg == sstore.MainViewSession {
-		update.AddUpdate(&sstore.MainViewUpdate{MainView: sstore.MainViewSession})
-	} else if mainViewArg == sstore.MainViewConnections {
-		update.AddUpdate(&sstore.MainViewUpdate{MainView: sstore.MainViewConnections})
-	} else if mainViewArg == sstore.MainViewSettings {
-		update.AddUpdate(&sstore.MainViewUpdate{MainView: sstore.MainViewSettings})
-	} else if mainViewArg == sstore.MainViewHistory {
-		return nil, fmt.Errorf("use /history instead")
-	} else if mainViewArg == sstore.MainViewBookmarks {
-		return nil, fmt.Errorf("use /bookmarks instead")
-	} else {
-		return nil, fmt.Errorf("unrecognized main view")
-	}
-	return update, nil
-}
-
 func SessionCommand(ctx context.Context, pk *scpacket.FeCommandPacketType) (scbus.UpdatePacket, error) {
 	ids, err := resolveUiIds(ctx, pk, 0)
 	if err != nil {

wavesrv/pkg/sstore/sstore.go

@@ -71,11 +71,9 @@ const (
 )
 
 const (
-	MainViewSession     = "session"
-	MainViewBookmarks   = "bookmarks"
-	MainViewHistory     = "history"
-	MainViewConnections = "connections"
-	MainViewSettings    = "clientsettings"
+	MainViewSession   = "session"
+	MainViewBookmarks = "bookmarks"
+	MainViewHistory   = "history"
 )
 
 const (