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>;