@devries-cameron20 / t3code Mirror · read-only / commits / eea9d15ee2
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 16:00 UTC

fix(desktop): Windows folders dropped on a WSL backend insert their WSL path (#30037)

Julius Marminge committed Nov 13, 2026 at 20:55 UTC eea9d15ee275858a681db6293dd35345bb338728
11 files changed +219 -42
apps/desktop/src/ipc/DesktopIpcHandlers.ts
+2
@@ -50,6 +50,7 @@ import {
50 probeRemoteEditors,
51 revealWindow,
52 pickFolder,
53 + toLocalBackendPath,
54 pickProjectFavicon,
55 pickThemeFiles,
56 setTheme,
@@ -145,6 +146,7 @@ export const installDesktopIpcHandlers = Effect.fn("desktop.ipc.installHandlers"
146 yield* ipc.handle(setWslOnly);
147
148 yield* ipc.handle(pickFolder);
149 + yield* ipc.handle(toLocalBackendPath);
150 yield* ipc.handle(pickProjectFavicon);
151 yield* ipc.handle(pickThemeFiles);
152 yield* ipc.handle(setTheme);
apps/desktop/src/ipc/channels.ts
+1
@@ -1,4 +1,5 @@
1 export const PICK_FOLDER_CHANNEL = "desktop:pick-folder";
2 +export const TO_LOCAL_BACKEND_PATH_CHANNEL = "desktop:to-local-backend-path";
3 export const SET_NOTIFICATION_BADGE_CHANNEL = "desktop:set-notification-badge";
4 export const PICK_PROJECT_FAVICON_CHANNEL = "desktop:pick-project-favicon";
5 export const PICK_THEME_FILES_CHANNEL = "desktop:pick-theme-files";
apps/desktop/src/ipc/methods/window.test.ts
+43
@@ -25,6 +25,7 @@ import * as DesktopBackendManager from "../../backend/DesktopBackendManager.ts";
25 import * as DesktopBackendPool from "../../backend/DesktopBackendPool.ts";
26 import * as DesktopAppSettings from "../../settings/DesktopAppSettings.ts";
27 import * as DesktopManagedPolicy from "../../app/DesktopManagedPolicy.ts";
28 +import * as DesktopWslEnvironment from "../../wsl/DesktopWslEnvironment.ts";
29 import * as ElectronDialog from "../../electron/ElectronDialog.ts";
30 import * as ElectronWindow from "../../electron/ElectronWindow.ts";
31 import * as IpcChannels from "../channels.ts";
@@ -36,6 +37,7 @@ import {
37 probeRemoteEditors,
38 readMedia,
39 syncHtmlFullscreen,
40 + toLocalBackendPath,
41 } from "./window.ts";
42
43 const readyWslConfig: DesktopBackendManager.DesktopBackendStartConfig = {
@@ -185,6 +187,47 @@ describe("getLocalEnvironmentBootstraps", () => {
187 });
188 });
189
190 +describe("toLocalBackendPath", () => {
191 + const { runningDistro: _, ...windowsConfig } = readyWslConfig;
192 + it.effect("converts paths through wslpath only for backends running in WSL", () =>
193 + Effect.gen(function* () {
194 + const convert = (backendId: string, path = "C:\\Users\\me\\project") =>
195 + toLocalBackendPath.handler({ backendId, path });
196 + assert.strictEqual(yield* convert("primary"), "C:\\Users\\me\\project");
197 + assert.strictEqual(yield* convert("wsl:default"), "/drives/c/Users/me/project");
198 + assert.strictEqual(yield* convert("wsl:missing"), null);
199 + assert.strictEqual(
200 + yield* convert("wsl:default", "\\\\wsl.localhost\\ubuntu\\home\\me\\repo"),
201 + "/home/me/repo",
202 + );
203 + assert.strictEqual(yield* convert("wsl:default", "\\\\wsl$\\Debian\\home\\me\\repo"), null);
204 + assert.strictEqual(
205 + yield* convert("primary", "\\\\wsl$\\Debian\\home\\me\\repo"),
206 + "\\\\wsl$\\Debian\\home\\me\\repo",
207 + );
208 + }).pipe(
209 + Effect.provide(
210 + Layer.mergeAll(
211 + DesktopBackendPool.layerTest([
212 + {
213 + ...defaultWslInstance,
214 + id: DesktopBackendManager.BackendInstanceId("primary"),
215 + currentConfig: Effect.succeedSome(windowsConfig),
216 + },
217 + defaultWslInstance,
218 + ]),
219 + DesktopWslEnvironment.layerTest({
220 + windowsToWslPath: (distro, windowsPath) =>
221 + distro === "Ubuntu" && windowsPath === "C:\\Users\\me\\project"
222 + ? Option.some("/drives/c/Users/me/project")
223 + : Option.none(),
224 + }),
225 + ),
226 + ),
227 + ),
228 + );
229 +});
230 +
231 describe("installRelayTelemetryEnabled", () => {
232 // The renderer reads this over sync IPC, so the answer must not wait on the filesystem.
233 const relayTelemetryEnabled = (
apps/desktop/src/ipc/methods/window.ts
+34 -10
@@ -25,6 +25,7 @@ import * as Option from "effect/Option";
25 import * as Schema from "effect/Schema";
26
27 import * as DesktopBackendConfiguration from "../../backend/DesktopBackendConfiguration.ts";
28 +import * as DesktopBackendManager from "../../backend/DesktopBackendManager.ts";
29 import * as DesktopBackendPool from "../../backend/DesktopBackendPool.ts";
30 import * as DesktopLocalEnvironmentAuth from "../../backend/DesktopLocalEnvironmentAuth.ts";
31 import * as DesktopEnvironment from "../../app/DesktopEnvironment.ts";
@@ -204,6 +205,20 @@ export const getLocalEnvironmentBearerToken = DesktopIpc.makeIpcMethod({
205 }),
206 });
207
208 +// Ask the distro: its automount root is configurable, so /mnt/<drive> is only the default.
209 +const windowsPathToWsl = Effect.fn("desktop.ipc.window.windowsPathToWsl")(function* (
210 + distro: string | null,
211 + windowsPath: string,
212 +) {
213 + const linuxUncPath = wslUncPathToLinuxPath(windowsPath);
214 + if (linuxUncPath !== null) return Option.some(linuxUncPath);
215 + const wslEnvironment = yield* DesktopWslEnvironment.DesktopWslEnvironment;
216 + return yield* wslEnvironment.windowsToWslPath(
217 + extractDistroFromUncPath(windowsPath) ?? distro,
218 + windowsPath,
219 + );
220 +});
221 +
222 export const pickFolder = DesktopIpc.makeIpcMethod({
223 channel: IpcChannels.PICK_FOLDER_CHANNEL,
224 payload: Schema.UndefinedOr(PickFolderOptionsSchema),
@@ -250,20 +265,29 @@ export const pickFolder = DesktopIpc.makeIpcMethod({
265 if (!useWsl) {
266 return selectedPath.value;
267 }
253 -
254 - const linuxUncPath = wslUncPathToLinuxPath(selectedPath.value);
255 - if (linuxUncPath !== null) {
256 - return linuxUncPath;
257 - }
258 -
259 - const converted = yield* wslEnvironment.windowsToWslPath(
260 - extractDistroFromUncPath(selectedPath.value) ?? wslDistro,
261 - selectedPath.value,
262 - );
268 + const converted = yield* windowsPathToWsl(wslDistro, selectedPath.value);
269 return Option.getOrElse(converted, () => selectedPath.value);
270 }),
271 });
272
273 +export const toLocalBackendPath = DesktopIpc.makeIpcMethod({
274 + channel: IpcChannels.TO_LOCAL_BACKEND_PATH_CHANNEL,
275 + payload: Schema.Struct({ backendId: Schema.String, path: Schema.String }),
276 + result: Schema.NullOr(Schema.String),
277 + handler: Effect.fn("desktop.ipc.window.toLocalBackendPath")(function* ({ backendId, path }) {
278 + const pool = yield* DesktopBackendPool.DesktopBackendPool;
279 + const instance = yield* pool.get(DesktopBackendManager.BackendInstanceId(backendId));
280 + if (Option.isNone(instance)) return null;
281 + const config = yield* instance.value.currentConfig;
282 + if (Option.isNone(config) || Option.isSome(config.value.preflightFailure)) return null;
283 + const { runningDistro } = config.value;
284 + if (runningDistro === undefined) return path;
285 + const uncDistro = extractDistroFromUncPath(path);
286 + if (uncDistro !== null && uncDistro.toLowerCase() !== runningDistro.toLowerCase()) return null;
287 + return Option.getOrNull(yield* windowsPathToWsl(runningDistro, path));
288 + }),
289 +});
290 +
291 export const pickProjectFavicon = DesktopIpc.makeIpcMethod({
292 channel: IpcChannels.PICK_PROJECT_FAVICON_CHANNEL,
293 payload: Schema.UndefinedOr(Schema.String),
apps/desktop/src/preload.ts
+2
@@ -238,6 +238,8 @@ contextBridge.exposeInMainWorld("desktopBridge", {
238 setWslDistro: (distro) => ipcRenderer.invoke(IpcChannels.SET_WSL_DISTRO_CHANNEL, distro),
239 setWslOnly: (enabled) => ipcRenderer.invoke(IpcChannels.SET_WSL_ONLY_CHANNEL, enabled),
240 pickFolder: (options) => ipcRenderer.invoke(IpcChannels.PICK_FOLDER_CHANNEL, options),
241 + toLocalBackendPath: (backendId, path) =>
242 + ipcRenderer.invoke(IpcChannels.TO_LOCAL_BACKEND_PATH_CHANNEL, { backendId, path }),
243 pickProjectFavicon: (initialPath) =>
244 ipcRenderer.invoke(IpcChannels.PICK_PROJECT_FAVICON_CHANNEL, initialPath),
245 pickThemeFiles: () => ipcRenderer.invoke(IpcChannels.PICK_THEME_FILES_CHANNEL, undefined),
apps/desktop/src/wsl/DesktopWslEnvironment.test.ts
+49
@@ -4,8 +4,11 @@ import { assert, describe, it } from "@effect/vitest";
4 import * as Effect from "effect/Effect";
5 import * as FileSystem from "effect/FileSystem";
6 import * as Layer from "effect/Layer";
7 +import * as Option from "effect/Option";
8 import * as Path from "effect/Path";
9 import * as Redacted from "effect/Redacted";
10 +import * as Sink from "effect/Sink";
11 +import * as Stream from "effect/Stream";
12 import { ChildProcess, ChildProcessSpawner } from "effect/process";
13 import { afterAll, expect } from "vite-plus/test";
14 import * as NodeChildProcess from "node:child_process";
@@ -24,6 +27,7 @@ import {
27 buildWslRuntimeProbeScript,
28 parseResolvedPath,
29 parseWslRuntimeRoot,
30 + windowsToWslPathImpl,
31 } from "./DesktopWslEnvironment.ts";
32
33 // The install script only fails the way this file cares about when a real shell
@@ -552,3 +556,48 @@ describe("makeIsAvailable", () => {
556 }),
557 );
558 });
559 +
560 +describe("windowsToWslPathImpl", () => {
561 + it.effect("runs wslpath without a shell so folder names stay one literal argument", () =>
562 + Effect.gen(function* () {
563 + const spawned: Array<ChildProcess.Command> = [];
564 + const stdout = Stream.make(new TextEncoder().encode("/mnt/c/a$b & c;(d)\n"));
565 + const spawner = ChildProcessSpawner.make((command) => {
566 + spawned.push(command);
567 + return Effect.succeed(
568 + ChildProcessSpawner.makeHandle({
569 + pid: ChildProcessSpawner.ProcessId(1),
570 + stdout,
571 + stderr: Stream.empty,
572 + all: stdout,
573 + exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(0)),
574 + isRunning: Effect.succeed(false),
575 + kill: () => Effect.void,
576 + stdin: Sink.drain,
577 + getInputFd: () => Sink.drain,
578 + getOutputFd: () => Stream.empty,
579 + unref: Effect.succeed(Effect.void),
580 + }),
581 + );
582 + });
583 +
584 + const converted = yield* windowsToWslPathImpl("Ubuntu", "C:\\a$b & c;(d)").pipe(
585 + Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
586 + );
587 +
588 + assert.deepStrictEqual(converted, Option.some("/mnt/c/a$b & c;(d)"));
589 + assert.lengthOf(spawned, 1);
590 + const [command] = spawned;
591 + assert(command?._tag === "StandardCommand");
592 + assert.strictEqual(command.command, "wsl.exe");
593 + assert.deepStrictEqual(command.args, [
594 + "-d",
595 + "Ubuntu",
596 + "--exec",
597 + "wslpath",
598 + "-u",
599 + "C:/a$b & c;(d)",
600 + ]);
601 + }),
602 + );
603 +});
apps/desktop/src/wsl/DesktopWslEnvironment.ts
+3 -2
@@ -1035,7 +1035,7 @@ const preWarmImpl = (
1035 }),
1036 ).pipe(Effect.timeoutOption(PRE_WARM_TIMEOUT), Effect.ignore);
1037
1038 -const windowsToWslPathImpl = (
1038 +export const windowsToWslPathImpl = (
1039 distro: string | null,
1040 windowsPath: string,
1041 ): Effect.Effect<Option.Option<string>, never, ChildProcessSpawner.ChildProcessSpawner> => {
@@ -1046,7 +1046,8 @@ const windowsToWslPathImpl = (
1046 const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
1047 const command = ChildProcess.make(
1048 "wsl.exe",
1049 - [...buildDistroArgs(distro), "--", "wslpath", "-u", normalized],
1049 + // --exec skips the distro shell, which would expand `$`, `&` or `;` in folder names.
1050 + [...buildDistroArgs(distro), "--exec", "wslpath", "-u", normalized],
1051 {
1052 stdin: "ignore",
1053 stdout: "pipe",
apps/web/src/components/chat/ChatComposer.tsx
+56 -17
@@ -44,6 +44,7 @@ import {
44 ProviderDriverKind,
45 ProviderInstanceId,
46 PROVIDER_SEND_TURN_MAX_ATTACHMENTS,
47 + PRIMARY_LOCAL_ENVIRONMENT_ID,
48 } from "@t3tools/contracts";
49 import type { EnvironmentConnectionPresentation } from "@t3tools/client-runtime/connection";
50 import { settlePromise, squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";
@@ -52,7 +53,7 @@ import { formatComposerModelMention } from "@t3tools/client-runtime/composer-mod
53 import { isPasteAsTextShortcut } from "@t3tools/client-runtime/text-paste";
54 import { scopedThreadKey, scopeThreadRef } from "@t3tools/client-runtime/environment";
55 import { serializeComposerFileLink } from "@t3tools/shared/composerTrigger";
55 -import { folderDropTarget, resolveDroppedFolderPath } from "./folderDrop";
56 +import { type FolderDropTarget, folderDropTarget, resolveDroppedFolderPath } from "./folderDrop";
57 import { splitTransferredFiles } from "./workspaceFileDrop";
58 import { createModelSelection, normalizeModelSlug } from "@t3tools/shared/model";
59 import { USAGE_LIMITS_COMMAND } from "@t3tools/shared/usageLimits";
@@ -666,6 +667,14 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
667 useLayoutEffect(() => {
668 attachmentTargetKeyRef.current = attachmentTargetKey;
669 });
670 + const composerMountedRef = useRef(true);
671 + // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- tracks unmount so an awaited folder conversion cannot write into ChatView's reused promptRef
672 + useLayoutEffect(() => {
673 + composerMountedRef.current = true;
674 + return () => {
675 + composerMountedRef.current = false;
676 + };
677 + }, []);
678 const questionPreparations = useQuestionAttachmentPreparation((state) => state.counts);
679 const prompt = composerDraft.prompt;
680 const composerImages = attachmentDraft.images;
@@ -2649,23 +2658,22 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
2658 };
2659 const insertComposerTextAtEndStable = useStableCallback(insertComposerTextAtEnd);
2660
2652 - const addComposerFolders = (folders: File[]) => {
2653 - const target = folderDropTarget({
2654 - localEnvironmentDisabled: isLocalEnvironmentDisabled(),
2655 - environmentId,
2656 - primaryEnvironmentId,
2657 - connection: readPreparedConnection(environmentId),
2658 - isDesktopRenderer: window.desktopBridge !== undefined,
2659 - });
2660 - if (target === "remote") {
2661 - toastManager.add({
2662 - type: "error",
2663 - title: "Folders can only be referenced on a server running on this computer",
2664 - });
2665 - return;
2666 - }
2661 + const insertComposerFolders = async (
2662 + folders: File[],
2663 + target: FolderDropTarget,
2664 + draftKey: string,
2665 + ) => {
2666 + const bridge = window.desktopBridge;
2667 for (const folder of folders) {
2668 - const path = resolveDroppedFolderPath(folder, window.desktopBridge?.getPathForFile);
2668 + const droppedPath = resolveDroppedFolderPath(folder, bridge?.getPathForFile);
2669 + const path =
2670 + droppedPath === null || typeof target === "string"
2671 + ? droppedPath
2672 + : ((await bridge
2673 + ?.toLocalBackendPath(target.wslBackendId, droppedPath)
2674 + .catch(() => null)) ?? null);
2675 + // ChatView is reused across threads, so a slow conversion must not land in the next draft.
2676 + if (!composerMountedRef.current || attachmentTargetKeyRef.current !== draftKey) return;
2677 if (path === null) {
2678 toastManager.add({
2679 type: "error",
@@ -2688,6 +2696,37 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
2696 }
2697 focusComposer();
2698 };
2699 +
2700 + const addComposerFolders = (folders: File[]) => {
2701 + const target = folderDropTarget({
2702 + localEnvironmentDisabled: isLocalEnvironmentDisabled(),
2703 + environmentId,
2704 + primaryEnvironmentId,
2705 + connection: readPreparedConnection(environmentId),
2706 + isDesktopRenderer: window.desktopBridge !== undefined,
2707 + primaryRunsInWsl:
2708 + window.desktopBridge
2709 + ?.getLocalEnvironmentBootstraps()
2710 + .some(
2711 + (bootstrap) =>
2712 + bootstrap.id === PRIMARY_LOCAL_ENVIRONMENT_ID &&
2713 + typeof bootstrap.runningDistro === "string",
2714 + ) === true,
2715 + });
2716 + if (target === "remote") {
2717 + toastManager.add({
2718 + type: "error",
2719 + title: "Folders can only be referenced on a server running on this computer",
2720 + });
2721 + return;
2722 + }
2723 + const draftKey = attachmentTargetKeyRef.current;
2724 + // Hold send until every conversion lands, or the folder misses the message.
2725 + pendingDraftWork.begin(draftKey);
2726 + void insertComposerFolders(folders, target, draftKey).finally(() =>
2727 + pendingDraftWork.end(draftKey),
2728 + );
2729 + };
2730 const addComposerFoldersStable = useStableCallback(addComposerFolders);
2731
2732 const onComposerPaste = (event: React.ClipboardEvent<HTMLElement>) => {
apps/web/src/components/chat/folderDrop.test.ts
+15 -3
@@ -19,6 +19,7 @@ const thinClient = {
19 environmentId,
20 primaryEnvironmentId: null,
21 isDesktopRenderer: true,
22 + primaryRunsInWsl: false,
23 };
24
25 describe("folderDropTarget", () => {
@@ -33,6 +34,17 @@ describe("folderDropTarget", () => {
34 },
35 "local",
36 ],
37 + [
38 + "the bundled primary running in WSL",
39 + {
40 + ...thinClient,
41 + localEnvironmentDisabled: false,
42 + primaryEnvironmentId: environmentId,
43 + primaryRunsInWsl: true,
44 + connection: null,
45 + },
46 + { wslBackendId: "primary" },
47 + ],
48 [
49 "a saved loopback server on desktop",
50 { ...thinClient, connection: savedServer("http://127.0.0.1:3773") },
@@ -50,8 +62,8 @@ describe("folderDropTarget", () => {
62 ],
63 [
64 "a desktop WSL backend",
53 - { ...thinClient, connection: savedServer("http://127.0.0.1:3774", "local:wsl-ubuntu") },
54 - "remote",
65 + { ...thinClient, connection: savedServer("http://127.0.0.1:3774", "local:wsl:Ubuntu") },
66 + { wslBackendId: "wsl:Ubuntu" },
67 ],
68 [
69 "an SSH forward on loopback",
@@ -77,6 +89,6 @@ describe("folderDropTarget", () => {
89 ],
90 ["an unprepared connection", { ...thinClient, connection: null }, "remote"],
91 ] as const)("targets %s", (_name, input, expected) => {
80 - expect(folderDropTarget(input)).toBe(expected);
92 + expect(folderDropTarget(input)).toEqual(expected);
93 });
94 });
apps/web/src/components/chat/folderDrop.ts
+12 -10
@@ -1,31 +1,33 @@
1 import type { PreparedConnection } from "@t3tools/client-runtime/connection";
2 -import type { EnvironmentId } from "@t3tools/contracts";
2 +import { PRIMARY_LOCAL_ENVIRONMENT_ID, type EnvironmentId } from "@t3tools/contracts";
3
4 -import { isDesktopLocalConnectionTarget } from "~/connection/desktopLocal";
4 +import { desktopLocalBackendId, isDesktopLocalConnectionTarget } from "~/connection/desktopLocal";
5 import { isLoopbackHostname } from "~/environments/primary/target";
6
7 +export type FolderDropTarget = "local" | "remote" | { readonly wslBackendId: string };
8 +
9 export function folderDropTarget(input: {
10 localEnvironmentDisabled: boolean;
11 environmentId: EnvironmentId;
12 primaryEnvironmentId: EnvironmentId | null;
13 connection: Pick<PreparedConnection, "target" | "httpBaseUrl"> | null;
14 isDesktopRenderer: boolean;
13 -}): "local" | "remote" {
15 + primaryRunsInWsl: boolean;
16 +}): FolderDropTarget {
17 if (
18 !input.localEnvironmentDisabled &&
19 input.primaryEnvironmentId !== null &&
20 input.environmentId === input.primaryEnvironmentId
21 ) {
19 - return "local";
22 + return input.primaryRunsInWsl ? { wslBackendId: PRIMARY_LOCAL_ENVIRONMENT_ID } : "local";
23 }
21 - return input.isDesktopRenderer &&
22 - input.connection !== null &&
23 - isSavedLoopbackConnection(input.connection)
24 - ? "local"
25 - : "remote";
24 + if (!input.isDesktopRenderer || input.connection === null) return "remote";
25 + const backendId = desktopLocalBackendId(input.connection.target);
26 + if (backendId?.startsWith("wsl:")) return { wslBackendId: backendId };
27 + return isSavedLoopbackConnection(input.connection) ? "local" : "remote";
28 }
29
28 -// A direct saved connection to loopback shares the desktop's filesystem; WSL backends and SSH forwards do not.
30 +// A direct saved connection to loopback shares the desktop's filesystem; SSH forwards do not.
31 function isSavedLoopbackConnection({
32 target,
33 httpBaseUrl,
packages/contracts/src/ipc.ts
+2
@@ -1127,6 +1127,8 @@ export interface DesktopBridge {
1127 setWslDistro: (distro: string | null) => Promise<DesktopWslState>;
1128 setWslOnly: (enabled: boolean) => Promise<DesktopWslState>;
1129 pickFolder: (options?: PickFolderOptions) => Promise<string | null>;
1130 + /** Maps a Windows path to the one a local backend (`primary` or `wsl:…`) sees; null when it cannot. */
1131 + toLocalBackendPath: (backendId: string, windowsPath: string) => Promise<string | null>;
1132 pickProjectFavicon: (initialPath?: string) => Promise<string | null>;
1133 pickThemeFiles: () => Promise<readonly PickedThemeFile[] | null>;
1134 setTheme: (theme: DesktopTheme) => Promise<void>;