The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
fix(remote): keep keymap and UI preferences local in remote windows (#298)
l0ng-ai3bb994062d5e
diff --git a/src/platform/clientSettings.ts b/src/platform/clientSettings.tsnew file mode 100644index 000000000..77f504379--- /dev/null+++ b/src/platform/clientSettings.ts@@ -0,0 +1,102 @@+/** Settings model ownership: these UI preferences belong to the client, including their descendants.+ * Mixed sections deliberately list individual keys so project/tooling settings stay on the host.+ * Keep this module dependency-free: the transport also consumes this metadata.+ */+export const CLIENT_SETTINGS_KEYS = [+ "keymap",+ "keymapOverrides",+ "customKeymaps",+ "appearance",+ "notifications",+ "general.reopenLastProject",+ "general.confirmExit",+ "general.openProjectIn",+ "general.dateFormat",+ "editor.fontFamily",+ "editor.fontSize",+ "editor.lineHeight",+ "editor.ligatures",+ "editor.fallbackFont",+ "editor.fontWeight",+ "editor.boldFontWeight",+ "editor.colorScheme",+ "editor.colorOverrides",+ "editor.semanticHighlighting",+ "editor.rainbowBrackets",+ "editor.softWrap",+ "editor.showWhitespace",+ "editor.inlayHints",+ "editor.stickyScroll",+ "editor.appearance",+ "editor.breadcrumbs",+ "editor.folding",+ "editor.tabs",+ "editor.codeEditing",+ "editor.inlay",+ "editor.gutterIconsDisabled",+ "editor.showGutterIcons",+ "editor.general.wheelZoom",+ "editor.general.dragAndDrop",+ "editor.general.caretScroll",+ "editor.general.softWrapFiles",+ "editor.general.softWrapIndent",+ "editor.general.scrollPastEnd",+ "editor.general.richTextCopy",+ "editor.codeStyle.visualGuides",+ "terminal.tabName",+ "terminal.audibleBell",+ "terminal.closeOnExit",+ "terminal.mouseReporting",+ "terminal.copyOnSelection",+ "terminal.pasteOnMiddleClick",+ "terminal.overrideIdeShortcuts",+ "terminal.highlightHyperlinks",+ "terminal.optionAsMeta",+ "terminal.escapeToEditor",+ "terminal.cursorShape",+ "terminal.cursorBlink",+ "terminal.useEditorFont",+ "terminal.fontFamily",+ "terminal.fontSize",+ "terminal.lineHeight",+ "terminal.fallbackFontFamily",+ "terminal.columnWidth",+ "console.softWrap",+ "console.foldPatterns",+ "debugger.showOnBreakpoint",+ "debugger.focusAppOnBreakpoint",+ "debugger.hideOnTermination",+ "debugger.runToCursorInlay",+ "debugger.inlineValues",+ "debugger.sortValues",+ "debugger.valueTooltip",+ "debugger.valueTooltipOnSelection",+ "debugger.valueTooltipDelay",+ "run.confirmRerun",+ "run.confirmTerminate",+ "run.showOnStart",+ "vcs.showDirtyDirectories",+ "vcs.git.showPushDialog",+ "vcs.git.pushDialogOnlyProtected",+ "vcs.git.combineStashAndShelf",+ "vcs.commit.nonModal",+ "vcs.commit.showRightMargin",+] as const;++export function isClientSetting(key: string): boolean {+ return CLIENT_SETTINGS_KEYS.some((root) => key === root || key.startsWith(`${root}.`));+}++/** Overlay from local globals, never from the local window's project layer. Missing client keys+ * also replace remote values, so older local settings fall back to client defaults.+ */+export function overlayClientSettings<T>(remote: T, local: unknown): T {+ const object = (value: unknown): Record<string, unknown> =>+ value && typeof value === "object" ? (value as Record<string, unknown>) : {};+ const copy = (target: unknown, source: unknown, path: string[]): unknown => {+ const [head, ...tail] = path;+ const value = object(source)[head!];+ return { ...object(target), [head!]: tail.length ? copy(object(target)[head!], value, tail) : value };+ };+ return CLIENT_SETTINGS_KEYS.reduce((settings, key) => copy(settings, local, key.split(".")) as T, remote);+}diff --git a/src/platform/remote.ts b/src/platform/remote.tsindex 348d030de..7d62446f9 100644--- a/src/platform/remote.ts+++ b/src/platform/remote.ts@@ -8,6 +8,8 @@ import { Channel, type InvokeArgs, type InvokeOptions } from "@tauri-apps/api/coimport { invokeLocal, setInvokeRoute, type InvokeRoute } from "./tauriCore";import { create } from "zustand";import { call, commands, isTauri, type ChannelFrame, type RemoteProgress, type RemoteSession } from "./ipc";+import { isClientSetting, overlayClientSettings } from "./clientSettings";+import type { Settings } from "./ipc";import { useProject } from "./project";interface RemoteState {@@ -51,25 +53,46 @@ async function remoteInvoke(cmd: string, args?: InvokeArgs, options?: InvokeOpti/*** Where a command of a remote window runs. Local always: opening a project (a* local folder; leaving the remote one) and closing it (that drops the- * connection, which ends the server's session). Both: a global setting, which+ * connection, which ends the server's session). Client UI settings stay local.+ * Both: a global tooling setting, which* the server's language servers and the local windows read.*/export function remoteRouting(cmd: string, args: InvokeArgs | undefined, served: ReadonlySet<string>) {- if (cmd === "system_font_families") return "local";+ if (cmd === "system_font_families" || cmd === "settings_get_global") return "local";+ if (cmd === "settings_set" && isClientSetting((args as { key?: string } | undefined)?.key ?? "")) return "local";if (!served.has(cmd) || cmd === "open_project" || cmd === "close_project") return "local";if (cmd === "settings_set" && (args as { scope?: string } | undefined)?.scope === "global") return "both";return "remote";}+/** All effective settings responses use the same client overlay, including writes and project snapshots. */+async function clientSettings<T extends Settings>(settings: T): Promise<T> {+ return overlayClientSettings(settings, await invokeLocal<Settings>("settings_get_global"));+}+const route: InvokeRoute = (cmd, args, options) => {- switch (remoteRouting(cmd, args, routed)) {- case "local":- return null;- case "remote":- return remoteInvoke(cmd, args, options);- case "both":- return invokeLocal(cmd, args, options).then(() => remoteInvoke(cmd, args, options));+ const destination = remoteRouting(cmd, args, routed);+ if (cmd === "settings_set") {+ const setting = args as { scope: string; key: string; value: string };+ return (async () => {+ if (isClientSetting(setting.key)) {+ await invokeLocal(cmd, { ...setting, scope: "global" }, options);+ return clientSettings((await remoteInvoke("settings_get")) as Settings);+ }+ if (destination === "local") return invokeLocal(cmd, args, options);+ if (destination === "both") await invokeLocal(cmd, args, options);+ return clientSettings((await remoteInvoke(cmd, args, options)) as Settings);+ })();}+ if (destination === "local") return null;+ return remoteInvoke(cmd, args, options).then(async (result) => {+ if (cmd === "settings_get") return clientSettings(result as Settings);+ if (cmd === "project_current" && result) {+ const project = result as { settings: Settings };+ return { ...project, settings: await clientSettings(project.settings) };+ }+ return result;+ });};/** Routes the commands the server answers (`session.commands`) to it from now on. */@@ -115,6 +138,7 @@ export async function connectRemote(sshConfig: string, path: string) {try {const r = await call(commands.remoteConnect(sshConfig, path, onProgress));enableRemote({ sshConfig: r.sshConfig, root: r.root, host: r.host, commands: r.commands });+ r.project.settings = await clientSettings(r.project.settings);useProject.setState({ project: r.project, settings: r.project.settings });rememberRemote({sshConfig: r.sshConfig,diff --git a/src/platform/remoteSettings.test.ts b/src/platform/remoteSettings.test.tsnew file mode 100644index 000000000..1de70988e--- /dev/null+++ b/src/platform/remoteSettings.test.ts@@ -0,0 +1,168 @@+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";+import { CLIENT_SETTINGS_KEYS } from "./clientSettings";+import { commands, call, type Settings } from "./ipc";+import { loadSettings, useProject } from "./project";+import { connectRemote, disableRemote, enableRemote, remoteRouting } from "./remote";++const handlers = vi.hoisted(() => new Map<string, () => void>());+vi.mock("./ipc", async (original) => ({+ ...(await original<typeof import("./ipc")>()),+ onIdeEvent: (event: string, handler: () => void) => {+ handlers.set(event, handler);+ return () => handlers.delete(event);+ },+}));+import { trackRuntimeSettings } from "@/features/settings/runtime";++const local = {+ keymap: "my-map",+ keymapOverrides: { "editor.copy": ["Meta+J"] },+ customKeymaps: {+ "my-map": { name: "Mine", parent: "vscode-macos", overrides: { "editor.paste": ["Meta+K"] } },+ },+ appearance: { theme: "dark" },+ editor: { fontSize: 19, tabSize: 8 },+ terminal: { fontSize: 18, shellPath: "/local" },+};+const remote = {+ keymap: "intellij-linux",+ keymapOverrides: {},+ customKeymaps: {},+ appearance: { theme: "light" },+ editor: { fontSize: 13, tabSize: 2 },+ terminal: { fontSize: 13, shellPath: "/remote" },+};+const served = new Set(["settings_get", "settings_set", "project_current"]);+let invoke: ReturnType<typeof vi.fn>;++beforeEach(() => {+ useProject.setState({ opening: true });+ invoke = vi.fn(async (cmd: string, _args?: unknown, _options?: unknown) =>+ cmd === "remote_invoke" ? JSON.stringify(remote) : local,+ );+ Object.assign(window, { __TAURI_INTERNALS__: { invoke, transformCallback: () => 1 } });+ enableRemote({ sshConfig: "test", root: "/remote", host: "test", commands: [...served] });+});+afterEach(() => {+ disableRemote();+ useProject.setState({ opening: false, settings: null });+});++describe("remote client settings", () => {+ it.each([...CLIENT_SETTINGS_KEYS, "customKeymaps.mine", "keymapOverrides.editor.copy", "appearance.theme"])(+ "keeps %s writes local in either scope",+ (key) => {+ for (const scope of ["global", "project"])+ expect(remoteRouting("settings_set", { scope, key, value: "null" }, served)).toBe("local");+ },+ );+ it.each([+ "editor.tabSize",+ "editor.formatOnSave",+ "editor.codeStyle.languages",+ "terminal.shellPath",+ "terminal.env",+ "tools.node",+ "languages.python.interpreter",+ "keymapExtra",+ ])("preserves routing for host setting %s", (key) => {+ expect(remoteRouting("settings_set", { scope: "project", key }, served)).toBe("remote");+ expect(remoteRouting("settings_set", { scope: "global", key }, served)).toBe("both");+ });+ it("merges settings before publishing a newly connected project", async () => {+ disableRemote();+ invoke.mockImplementation(async (cmd: string) =>+ cmd === "remote_connect"+ ? {+ sshConfig: "test",+ root: "/remote",+ host: "test",+ commands: [...served],+ project: { root: "/remote", name: "remote", settings: remote },+ }+ : local,+ );+ await connectRemote("test", "/remote");+ expect(useProject.getState().settings).toMatchObject({ keymap: "my-map", editor: { tabSize: 2, fontSize: 19 } });+ });+ it("overlays the project snapshot used by the settings window", async () => {+ invoke.mockImplementation(async (cmd: string) =>+ cmd === "remote_invoke" ? JSON.stringify({ root: "/remote", settings: remote }) : local,+ );+ expect((await commands.projectCurrent())?.settings).toMatchObject({+ keymap: "my-map",+ editor: { tabSize: 2, fontSize: 19 },+ });+ });+ it("keeps client preferences after a remote tooling write", async () => {+ expect(await call(commands.settingsSet("project", "editor.tabSize", "2"))).toMatchObject({+ keymap: "my-map",+ editor: { fontSize: 19, tabSize: 2 },+ });+ expect(invoke.mock.calls.some(([cmd]) => cmd === "settings_set")).toBe(false);+ });+ it("keeps local overrides through a settingsChanged runtime reload", async () => {+ vi.useFakeTimers();+ await loadSettings();+ const stop = trackRuntimeSettings();+ try {+ handlers.get("settingsChanged")!();+ await vi.advanceTimersByTimeAsync(40);+ expect(useProject.getState().settings?.keymapOverrides).toEqual(local.keymapOverrides);+ expect(useProject.getState().settings?.keymap).toBe("my-map");+ } finally {+ stop();+ vi.useRealTimers();+ }+ });+ it("reloads local preferences instead of retaining stale or remote overrides", async () => {+ await loadSettings();+ invoke.mockImplementation(async (cmd: string) =>+ cmd === "remote_invoke" ? JSON.stringify(remote) : { ...local, keymapOverrides: {} },+ );+ await loadSettings();+ expect(useProject.getState().settings?.keymapOverrides).toEqual({});+ });+ it("does not inherit remote UI values when a local field is absent", async () => {+ invoke.mockImplementation(async (cmd: string) => (cmd === "remote_invoke" ? JSON.stringify(remote) : {}));+ await loadSettings();+ expect(useProject.getState().settings?.keymap).toBeUndefined();+ expect(useProject.getState().settings?.editor?.tabSize).toBe(2);+ });+ it("leaves local windows unchanged", async () => {+ disableRemote();+ await loadSettings();+ expect(useProject.getState().settings).toEqual(local);+ expect(invoke).toHaveBeenCalledTimes(1);+ });+ it("preserves client keymaps and UI settings when loading remote settings", async () => {+ await loadSettings();+ const settings = useProject.getState().settings as Settings;+ expect(settings).toMatchObject({+ ...local,+ editor: { fontSize: 19, tabSize: 2 },+ terminal: { fontSize: 18, shellPath: "/remote" },+ });+ expect(invoke).toHaveBeenCalledWith("settings_get_global", {}, undefined);+ });+ it("shows client preferences in the global settings dialog snapshot", async () => {+ expect(await commands.settingsGetGlobal()).toMatchObject({+ keymap: "my-map",+ editor: { fontSize: 19, tabSize: 8 },+ });+ });+ it("writes a client preference only to local global settings and returns merged settings", async () => {+ const settings = await call(commands.settingsSet("project", "editor.fontSize", "19"));+ expect(invoke).toHaveBeenCalledWith(+ "settings_set",+ { scope: "global", key: "editor.fontSize", value: "19" },+ undefined,+ );+ expect(+ invoke.mock.calls.filter(+ ([cmd, args]) => cmd === "remote_invoke" && (args as { cmd?: string })?.cmd === "settings_set",+ ),+ ).toHaveLength(0);+ expect(settings).toMatchObject({ keymap: "my-map", editor: { fontSize: 19, tabSize: 2 } });+ });+});