@devries-cameron20 / t3code-1 / commits / a3cf3f0fe7
Fork 0

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

fix(server): the Files tree lists symlinked files and folders (#21920)

Co-authored-by: maria-rcks <maria@kuuro.net>

KishanRPatel committed Oct 30, 2026 at 13:29 UTC a3cf3f0fe7bf1598c6be9dea302e3867713ee2d9
2 files changed +172 -3
apps/server/src/workspace/WorkspaceEntries.test.ts
+108
@@ -1,4 +1,5 @@
1 // @effect-diagnostics nodeBuiltinImport:off
2 +import * as NodeFSP from "node:fs/promises";
3 import * as NodeServices from "@effect/platform-node/NodeServices";
4 import { it, afterEach, describe, expect } from "@effect/vitest";
5 import * as Effect from "effect/Effect";
@@ -132,6 +133,113 @@ it.layer(layerTest, { excludeTestServices: true })("WorkspaceEntries", (it) => {
133 }),
134 );
135
136 + it.effect("lists symlinks as what they point to, hiding ones that cannot be opened", () =>
137 + Effect.gen(function* () {
138 + const platform = yield* HostProcess.Platform;
139 + if (platform === "win32") return;
140 + const cwd = yield* makeTempDir({ git: true });
141 + const outside = yield* makeTempDir();
142 + const fileSystem = yield* FileSystem.FileSystem;
143 + const path = yield* Path.Path;
144 + yield* writeTextFile(cwd, "real.txt");
145 + yield* writeTextFile(cwd, "realdir/nested.txt");
146 + yield* writeTextFile(outside, "outside.txt");
147 + yield* fileSystem.symlink("real.txt", path.join(cwd, "link.txt"));
148 + yield* fileSystem.symlink("realdir", path.join(cwd, "linkdir"));
149 + yield* fileSystem.symlink(outside, path.join(cwd, "outside-link"));
150 + yield* fileSystem.symlink(".git", path.join(cwd, "git-link"));
151 + yield* fileSystem.symlink("missing", path.join(cwd, "dangling"));
152 +
153 + const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
154 + const root = yield* workspaceEntries.list({ cwd, directoryPath: "" });
155 + expect(root.entries.toSorted((a, b) => a.path.localeCompare(b.path))).toEqual([
156 + { path: "link.txt", kind: "file" },
157 + { path: "linkdir", kind: "directory" },
158 + { path: "real.txt", kind: "file" },
159 + { path: "realdir", kind: "directory" },
160 + ]);
161 + expect(yield* workspaceEntries.list({ cwd, directoryPath: "linkdir" })).toEqual({
162 + entries: [{ path: "linkdir/nested.txt", kind: "file" }],
163 + truncated: false,
164 + });
165 + }),
166 + );
167 +
168 + it.effect("hides folder links that lead back to a folder on the listed path", () =>
169 + // "Expand all folders" loads every folder it expands, so a link that loops would
170 + // keep nesting the same entries without end.
171 + Effect.gen(function* () {
172 + const platform = yield* HostProcess.Platform;
173 + if (platform === "win32") return;
174 + const cwd = yield* makeTempDir();
175 + const fileSystem = yield* FileSystem.FileSystem;
176 + const path = yield* Path.Path;
177 + yield* writeTextFile(cwd, "a/file.txt");
178 + yield* writeTextFile(cwd, "b/file.txt");
179 + yield* fileSystem.symlink(".", path.join(cwd, "self"));
180 + yield* fileSystem.symlink("..", path.join(cwd, "a/up"));
181 + yield* fileSystem.symlink("../b", path.join(cwd, "a/to-b"));
182 + yield* fileSystem.symlink("../a", path.join(cwd, "b/to-a"));
183 +
184 + const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
185 + const paths = (directoryPath: string) =>
186 + workspaceEntries
187 + .list({ cwd, directoryPath })
188 + .pipe(Effect.map(({ entries }) => entries.map((entry) => entry.path).toSorted()));
189 + expect(yield* paths("")).toEqual(["a", "b"]);
190 + // A link into a sibling folder is fine on its own...
191 + expect(yield* paths("a")).toEqual(["a/file.txt", "a/to-b"]);
192 + // ...but once followed, the sibling's link back is hidden.
193 + expect(yield* paths("a/to-b")).toEqual(["a/to-b/file.txt"]);
194 + }),
195 + );
196 +
197 + it.effect("resolves a folder of many symlinks in bounded batches", () =>
198 + Effect.gen(function* () {
199 + const platform = yield* HostProcess.Platform;
200 + if (platform === "win32") return;
201 + const cwd = yield* makeTempDir();
202 + const fileSystem = yield* FileSystem.FileSystem;
203 + const path = yield* Path.Path;
204 + // Shaped like a pnpm `node_modules`: one link per package into `.pnpm`.
205 + const directoryPath = [...Array.from({ length: 80 }, () => "nested"), "node_modules"].join(
206 + "/",
207 + );
208 + const packages = Array.from({ length: 200 }, (_, index) => `pkg-${index}`);
209 + yield* Effect.forEach(
210 + packages,
211 + (name) =>
212 + Effect.gen(function* () {
213 + yield* writeTextFile(cwd, `${directoryPath}/.pnpm/${name}/index.js`);
214 + yield* fileSystem.symlink(`.pnpm/${name}`, path.join(cwd, directoryPath, name));
215 + }),
216 + { concurrency: 32, discard: true },
217 + );
218 + const realpath = NodeFSP.realpath;
219 + let inFlight = 0;
220 + let maxInFlight = 0;
221 + vi.spyOn(NodeFSP, "realpath").mockImplementation((async (target: string) => {
222 + maxInFlight = Math.max(maxInFlight, ++inFlight);
223 + try {
224 + return await realpath(target);
225 + } finally {
226 + inFlight--;
227 + }
228 + }) as typeof NodeFSP.realpath);
229 +
230 + const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
231 + const { entries } = yield* workspaceEntries.list({ cwd, directoryPath });
232 + expect(entries.map((entry) => entry.path).toSorted()).toEqual(
233 + [
234 + `${directoryPath}/.pnpm`,
235 + ...packages.map((name) => `${directoryPath}/${name}`),
236 + ].toSorted(),
237 + );
238 + expect(entries.every((entry) => entry.kind === "directory")).toBe(true);
239 + expect(maxInFlight).toBeLessThanOrEqual(64);
240 + }),
241 + );
242 +
243 it.effect("labels the children of wide folders exactly as git does for each child", () =>
244 Effect.gen(function* () {
245 // Above 1,000 children, listing first asks whether the whole folder is ignored.
apps/server/src/workspace/WorkspaceEntries.ts
+64 -3
@@ -117,6 +117,9 @@ const IGNORED_FILES_LIMIT = 200;
117 /** Paths sent to one `git check-ignore` call when labelling a folder's children. */
118 const IGNORE_CHECK_CHUNK_SIZE = 1000;
119
120 +/** Children classified at once when listing a folder; each symlink costs a realpath and a stat. */
121 +const SYMLINK_RESOLVE_BATCH_SIZE = 64;
122 +
123 const resolveBrowseTarget = Effect.fn("WorkspaceEntries.resolveBrowseTarget")(function* (
124 input: FilesystemBrowseInput,
125 path: Path.Path,
@@ -318,13 +321,71 @@ export const make = Effect.gen(function* () {
321 throw new Error("Directory must be inside the workspace and outside .git.");
322 }
323 const children = await NodeFSP.readdir(directory, { withFileTypes: true });
324 + const isSameOrInside = (parent: string, child: string) => {
325 + const relativeChild = path.relative(parent, child);
326 + return (
327 + relativeChild !== ".." &&
328 + !relativeChild.startsWith(`..${path.sep}`) &&
329 + !path.isAbsolute(relativeChild)
330 + );
331 + };
332 + // Reject canonical ancestors so "Expand all folders" cannot follow a cycle.
333 + let visitedFolders: Promise<ReadonlyArray<string>> | undefined;
334 + const loadVisitedFolders = () =>
335 + (visitedFolders ??= (async () => {
336 + const folders = [root];
337 + let current = normalizedCwd;
338 + for (const segment of target.relativePath.split("/").filter(Boolean)) {
339 + current = path.join(current, segment);
340 + folders.push(await NodeFSP.realpath(current));
341 + }
342 + return folders;
343 + })());
344 + const resolveSymlinkKind = async (
345 + name: string,
346 + ): Promise<ProjectEntry["kind"] | undefined> => {
347 + const resolved = await NodeFSP.realpath(path.join(directory, name)).catch(
348 + () => undefined,
349 + );
350 + if (
351 + resolved === undefined ||
352 + !isSameOrInside(root, resolved) ||
353 + path.relative(root, resolved).split(path.sep).includes(".git")
354 + ) {
355 + return undefined;
356 + }
357 + const stat = await NodeFSP.stat(resolved).catch(() => undefined);
358 + if (stat?.isFile()) return "file";
359 + if (!stat?.isDirectory()) return undefined;
360 + const folders = await loadVisitedFolders();
361 + return folders.some((folder) => isSameOrInside(resolved, folder))
362 + ? undefined
363 + : "directory";
364 + };
365 + // Bound filesystem work for directories such as pnpm node_modules.
366 + const kinds: Array<ProjectEntry["kind"] | undefined> = [];
367 + for (let offset = 0; offset < children.length; offset += SYMLINK_RESOLVE_BATCH_SIZE) {
368 + kinds.push(
369 + ...(await Promise.all(
370 + children
371 + .slice(offset, offset + SYMLINK_RESOLVE_BATCH_SIZE)
372 + .map(async (child): Promise<ProjectEntry["kind"] | undefined> => {
373 + if (child.name === ".git") return undefined;
374 + if (child.isDirectory()) return "directory";
375 + if (child.isFile()) return "file";
376 + return child.isSymbolicLink() ? resolveSymlinkKind(child.name) : undefined;
377 + }),
378 + )),
379 + );
380 + }
381 return {
322 - entries: children.flatMap((child): ProjectEntry[] => {
323 - if (child.name === ".git" || (!child.isDirectory() && !child.isFile())) return [];
382 + entries: children.flatMap((child, index): ProjectEntry[] => {
383 + const kind = kinds[index];
384 + if (kind === undefined) return [];
385 return [
386 {
387 path: target.relativePath ? `${target.relativePath}/${child.name}` : child.name,
327 - kind: child.isDirectory() ? "directory" : "file",
388 + kind,
389 },
390 ];
391 }),