@theia/filesystem 1.77.0-next.7 → 1.77.0-next.77

package/src/browser/file-service-copy.spec.ts

@@ -0,0 +1,226 @@
+// *****************************************************************************
+// Copyright (C) 2026 Sahil Gupta and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+let disableJSDOM = enableJSDOM();
+
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+FrontendApplicationConfigProvider.set({});
+
+import { Disposable, URI } from '@theia/core';
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { FileSystemProvider, FileSystemProviderCapabilities } from '../common/files';
+import { FileService } from './file-service';
+
+disableJSDOM();
+
+function createMockProvider(caseSensitive: boolean): FileSystemProvider {
+    return {
+        capabilities: caseSensitive ? FileSystemProviderCapabilities.PathCaseSensitive : 0,
+        onDidChangeCapabilities: () => Disposable.NULL,
+        onDidChangeFile: () => Disposable.NULL,
+        onFileWatchError: () => Disposable.NULL,
+        watch: () => Disposable.NULL,
+        stat: () => { throw new Error('not implemented'); },
+        readdir: () => { throw new Error('not implemented'); },
+        readFile: () => { throw new Error('not implemented'); },
+        writeFile: () => { throw new Error('not implemented'); },
+        delete: () => { throw new Error('not implemented'); },
+        mkdir: () => { throw new Error('not implemented'); },
+        rename: () => { throw new Error('not implemented'); },
+        copy: () => { throw new Error('not implemented'); },
+    } as unknown as FileSystemProvider;
+}
+
+/** Resolve to the rejection reason of the given promise, or to `undefined` if it fulfills. */
+async function rejection(promise: Promise<unknown>): Promise<Error | undefined> {
+    try {
+        await promise;
+        return undefined;
+    } catch (error) {
+        return error as Error;
+    }
+}
+
+describe('FileService move/copy validation', () => {
+    const sandbox = sinon.createSandbox();
+    let fileService: FileService;
+    let provider: FileSystemProvider;
+    let existsStub: sinon.SinonStub;
+
+    before(() => {
+        disableJSDOM = enableJSDOM();
+    });
+
+    after(() => {
+        disableJSDOM();
+    });
+
+    afterEach(() => {
+        sandbox.restore();
+    });
+
+    /** Create a `FileService` backed by a single mock provider for both source and target. */
+    function setup(caseSensitive: boolean = true): void {
+        sandbox.restore();
+        fileService = new FileService();
+        provider = createMockProvider(caseSensitive);
+        /* eslint-disable @typescript-eslint/no-explicit-any */
+        sandbox.stub(fileService as any, 'withProvider').resolves(provider);
+        sandbox.stub(fileService as any, 'withReadProvider').resolves(provider);
+        sandbox.stub(fileService as any, 'withWriteProvider').resolves(provider);
+        // The error messages name the involved resources through the label provider.
+        (fileService as any).labelProvider = { getLongName: (resource: URI) => resource.path.toString() };
+        /* eslint-enable @typescript-eslint/no-explicit-any */
+        // By default the target does not exist yet, which is the case when pasting a folder into one of its own subfolders.
+        existsStub = sandbox.stub(fileService, 'exists').resolves(false);
+    }
+
+    function validate(source: string, target: string, mode: 'move' | 'copy'): Promise<unknown> {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return (fileService as any).doValidateMoveCopy(provider, new URI(source), provider, new URI(target), mode, false);
+    }
+
+    describe('source containing the target', () => {
+
+        it('should reject copying a folder into a subfolder of itself', async () => {
+            setup();
+            const error = await rejection(validate('file:///a', 'file:///a/b/a', 'copy'));
+            expect(error, 'copying a folder into its own subfolder was allowed').to.be.an.instanceOf(Error);
+            expect(error!.message).to.contain('is parent of target');
+        });
+
+        it('should reject moving a folder into a subfolder of itself', async () => {
+            setup();
+            const error = await rejection(validate('file:///a', 'file:///a/b', 'move'));
+            expect(error, 'moving a folder into its own subfolder was allowed').to.be.an.instanceOf(Error);
+            expect(error!.message).to.contain('is parent of target');
+        });
+
+        it('should reject a deeply nested target inside the source', async () => {
+            setup();
+            const error = await rejection(validate('file:///a', 'file:///a/b/c/d/a', 'copy'));
+            expect(error, 'copying a folder deep into its own subtree was allowed').to.be.an.instanceOf(Error);
+            expect(error!.message).to.contain('is parent of target');
+        });
+
+        it('should reject copying a folder into its own subfolder through FileService.copy', async () => {
+            setup();
+            const error = await rejection(fileService.copy(new URI('file:///a'), new URI('file:///a/b/a'), { fromUserGesture: false }));
+            expect(error, 'FileService.copy allowed a copy into the source subtree').to.be.an.instanceOf(Error);
+            expect(error!.message).to.contain('is parent of target');
+        });
+
+        it('should reject moving a folder into its own subfolder through FileService.move', async () => {
+            setup();
+            const error = await rejection(fileService.move(new URI('file:///a'), new URI('file:///a/b'), { fromUserGesture: false }));
+            expect(error, 'FileService.move allowed a move into the source subtree').to.be.an.instanceOf(Error);
+            expect(error!.message).to.contain('is parent of target');
+        });
+
+        it('should reject a target inside the source that only differs in case on a case-insensitive provider', async () => {
+            setup(false);
+            const error = await rejection(validate('file:///a', 'file:///A/b/a', 'copy'));
+            expect(error, 'a case-insensitive provider allowed a copy into the source subtree').to.be.an.instanceOf(Error);
+            expect(error!.message).to.contain('is parent of target');
+        });
+    });
+
+    describe('the same resource', () => {
+
+        it('should reject copying a resource onto itself', async () => {
+            setup();
+            const error = await rejection(validate('file:///a/b', 'file:///a/b', 'copy'));
+            expect(error, 'copying a resource onto itself was allowed').to.be.an.instanceOf(Error);
+            expect(error!.message).to.contain('is parent of target');
+        });
+
+        it('should reject moving a resource onto itself', async () => {
+            setup();
+            const error = await rejection(validate('file:///a/b', 'file:///a/b', 'move'));
+            expect(error, 'moving a resource onto itself was allowed').to.be.an.instanceOf(Error);
+            expect(error!.message).to.contain('is parent of target');
+        });
+    });
+
+    describe('unrelated and adjacent targets', () => {
+
+        it('should accept an unrelated target', async () => {
+            setup();
+            const result = await validate('file:///a', 'file:///c/a', 'copy');
+            expect(result).to.deep.equal({ exists: false, isSameResourceWithDifferentPathCase: false });
+        });
+
+        it('should accept a target whose path merely shares a prefix with the source', async () => {
+            setup();
+            const result = await validate('file:///a', 'file:///ab/a', 'copy');
+            expect(result).to.deep.equal({ exists: false, isSameResourceWithDifferentPathCase: false });
+        });
+
+        it('should accept a target in a different file system', async () => {
+            setup();
+            const result = await validate('file:///a', 'memory:///a/b/a', 'copy');
+            expect(result).to.deep.equal({ exists: false, isSameResourceWithDifferentPathCase: false });
+        });
+    });
+
+    describe('the target containing the source', () => {
+
+        it('should reject moving a resource onto the existing folder that contains it', async () => {
+            setup();
+            existsStub.resolves(true);
+            const error = await rejection(validate('file:///a/b', 'file:///a', 'move'));
+            expect(error, 'moving a resource onto its own parent folder was allowed').to.be.an.instanceOf(Error);
+            expect(error!.message).to.contain('would replace the folder it is contained in');
+        });
+    });
+
+    describe('case-only renames on a case-insensitive provider', () => {
+
+        it('should accept a case-only rename', async () => {
+            setup(false);
+            const result = await validate('file:///a/Foo', 'file:///a/foo', 'move');
+            expect(result).to.deep.equal({ exists: false, isSameResourceWithDifferentPathCase: true });
+        });
+
+        it('should accept a case-only rename of a nested resource', async () => {
+            setup(false);
+            const result = await validate('file:///a/b/Foo.ts', 'file:///a/b/foo.ts', 'move');
+            expect(result).to.deep.equal({ exists: false, isSameResourceWithDifferentPathCase: true });
+        });
+
+        it('should accept a case-only rename even when the target is reported as existing', async () => {
+            setup(false);
+            existsStub.resolves(true);
+            const result = await validate('file:///a/Foo', 'file:///a/foo', 'move');
+            expect(result).to.deep.equal({ exists: true, isSameResourceWithDifferentPathCase: true });
+        });
+
+        it('should reject a case-only copy', async () => {
+            setup(false);
+            const error = await rejection(validate('file:///a/Foo', 'file:///a/foo', 'copy'));
+            expect(error, 'a case-only copy was allowed').to.be.an.instanceOf(Error);
+            expect(error!.message).to.contain('is parent of target');
+        });
+
+        it('should accept a case-only rename on a case-sensitive provider as a distinct resource', async () => {
+            setup(true);
+            const result = await validate('file:///a/Foo', 'file:///a/foo', 'move');
+            expect(result).to.deep.equal({ exists: false, isSameResourceWithDifferentPathCase: false });
+        });
+    });
+});

package/src/browser/file-service.ts

@@ -24,9 +24,9 @@
 // and https://github.com/microsoft/vscode/blob/04c36be045a94fee58e5f8992d3e3fd980294a84/src/vs/workbench/services/workingCopy/common/workingCopyFileOperationParticipant.ts
 
 /* eslint-disable max-len */
+/* eslint-disable @stylistic/brace-style, @stylistic/semi-spacing */
 /* eslint-disable @typescript-eslint/no-shadow */
 /* eslint-disable no-null/no-null */
-/* eslint-disable @typescript-eslint/tslint/config */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { injectable, inject, named, postConstruct } from '@theia/core/shared/inversify';
@@ -201,7 +201,7 @@ export const FileServiceContribution = Symbol('FileServiceContribution');
  *         });
  *
  *     }
- *```
+ * ```
  */
 export interface FileServiceContribution {
     /**
@@ -515,7 +515,7 @@ export class FileService {
      */
     resolve(resource: URI, options: ResolveMetadataFileOptions): Promise<FileStatWithMetadata>;
     resolve(resource: URI, options?: ResolveFileOptions | undefined): Promise<FileStat>;
-    async resolve(resource: any, options?: any) {
+    async resolve(resource: any, options?: any): Promise<FileStat> {
         try {
             return await this.doResolveFile(resource, options);
         } catch (error) {
@@ -1282,7 +1282,7 @@ export class FileService {
                 throw new Error(nls.localizeByDefault("Unable to move/copy when source '{0}' is parent of target '{1}'.", this.resourceForError(source), this.resourceForError(target)));
             }
 
-            if (!isSameResourceWithDifferentPathCase && target.isEqualOrParent(source, isPathCaseSensitive)) {
+            if (!isSameResourceWithDifferentPathCase && source.isEqualOrParent(target, isPathCaseSensitive)) {
                 throw new Error(nls.localizeByDefault("Unable to move/copy when source '{0}' is parent of target '{1}'.", this.resourceForError(source), this.resourceForError(target)));
             }
         }
@@ -1295,7 +1295,7 @@ export class FileService {
             // it as it would delete the source as well. In this case we have to throw
             if (sourceProvider === targetProvider) {
                 const isPathCaseSensitive = !!(sourceProvider.capabilities & FileSystemProviderCapabilities.PathCaseSensitive);
-                if (source.isEqualOrParent(target, isPathCaseSensitive)) {
+                if (target.isEqualOrParent(source, isPathCaseSensitive)) {
                     throw new Error(nls.localizeByDefault("Unable to move/copy '{0}' into '{1}' since a file would replace the folder it is contained in.", this.resourceForError(source), this.resourceForError(target)));
                 }
             }

package/src/common/filesystem-watcher-protocol.ts

@@ -89,6 +89,10 @@ export interface FileSystemWatcherClient {
 
 export interface WatchOptions {
     ignored: string[];
+    /**
+     * Watch the whole subtree under the given path. Defaults to `true`.
+     */
+    recursive?: boolean;
 }
 export interface FileChange {
     uri: string;

package/src/electron-browser/file-dialog/electron-file-dialog-service.spec.ts

@@ -0,0 +1,57 @@
+// *****************************************************************************
+// Copyright (C) 2026 Vinay Kaushal and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+let disableJSDOM = enableJSDOM();
+
+import { expect } from 'chai';
+import { FileUri } from '@theia/core/lib/common/file-uri';
+import URI from '@theia/core/lib/common/uri';
+import { OpenFileDialogProps } from '../../browser/file-dialog';
+import { OpenDialogOptions } from '../../electron-common/electron-api';
+import { ElectronFileDialogService } from './electron-file-dialog-service';
+
+disableJSDOM();
+
+class TestElectronFileDialogService extends ElectronFileDialogService {
+    override toOpenDialogOptions(uri: URI, props: OpenFileDialogProps): OpenDialogOptions {
+        return super.toOpenDialogOptions(uri, props);
+    }
+}
+
+describe('ElectronFileDialogService', () => {
+
+    before(() => disableJSDOM = enableJSDOM());
+    after(() => disableJSDOM());
+
+    const uri = FileUri.create('/home/user');
+    const filters = { 'Theia Workspace': ['theia-workspace'] };
+
+    it('adds an All Files filter to the given filters', () => {
+        const options = new TestElectronFileDialogService().toOpenDialogOptions(uri, { title: 'Open', canSelectFiles: true, filters });
+        expect(options.filters).to.deep.equal([
+            { name: 'Theia Workspace', extensions: ['theia-workspace'] },
+            { name: 'All Files', extensions: ['*'] }
+        ]);
+    });
+
+    it('omits the All Files filter if it is disabled', () => {
+        const options = new TestElectronFileDialogService().toOpenDialogOptions(uri, { title: 'Open', canSelectFiles: true, filters, disableAllFilesFilter: true });
+        expect(options.filters).to.deep.equal([
+            { name: 'Theia Workspace', extensions: ['theia-workspace'] }
+        ]);
+    });
+});

package/src/electron-browser/file-dialog/electron-file-dialog-service.ts

@@ -136,7 +136,7 @@ export class ElectronFileDialogService extends DefaultFileDialogService {
                 result.filters.push({ name: label, extensions: extensions });
             }
 
-            if (props.canSelectFiles) {
+            if (props.canSelectFiles && !props.disableAllFilesFilter) {
                 if (filters.length > 0) {
                     result.filters.push({ name: 'All Files', extensions: ['*'] });
                 }

package/src/node/disk-file-system-provider.spec.ts

@@ -114,6 +114,35 @@ describe('disk-file-system-provider', () => {
             }
         });
 
+        it('handles errors during temporary cleanup', async () => {
+            const tempDirPath = tracked.mkdirSync();
+            const provider = fsProvider as unknown as {
+                rimrafMove(path: string): Promise<void>;
+                rimrafUnlink(path: string): Promise<void>;
+                logger: ILogger;
+            };
+            const originalRimrafUnlink = provider.rimrafUnlink;
+            const originalWarn = provider.logger.warn;
+            let resolveWarning!: () => void;
+            const warningHandled = new Promise<void>(resolve => {
+                resolveWarning = resolve;
+            });
+            provider.rimrafUnlink = async path => {
+                await fs.rm(path, { recursive: true, force: true });
+                throw new Error('Cleanup failed');
+            };
+            provider.logger.warn = async () => {
+                resolveWarning();
+            };
+            try {
+                await provider.rimrafMove(tempDirPath);
+                await warningHandled;
+            } finally {
+                provider.rimrafUnlink = originalRimrafUnlink;
+                provider.logger.warn = originalWarn;
+            }
+        });
+
         it('delete is able to delete file', async function (): Promise<void> {
             this.timeout(10000);
             // Place the temp dir under $HOME so the XDG trash dir (~/.local/share/Trash) is on the same

package/src/node/disk-file-system-provider.ts

@@ -541,7 +541,9 @@ export class DiskFileSystemProvider implements Disposable,
             }
 
             // Delete but do not return as promise
-            this.rimrafUnlink(pathInTemp);
+            this.rimrafUnlink(pathInTemp).catch(error => {
+                this.logger.warn(`Failed to clean up temporary rimraf folder '${pathInTemp}':`, error);
+            });
         } catch (error) {
             if (error.code !== 'ENOENT') {
                 throw error;
@@ -833,7 +835,8 @@ export class DiskFileSystemProvider implements Disposable,
         };
         watcherService.watchFileChanges(resource.toString(), {
             // Convert from `files.WatchOptions` to internal `watcher-protocol.WatchOptions`:
-            ignored: opts.excludes
+            ignored: opts.excludes,
+            recursive: opts.recursive
         }).then(watcherId => {
             if (handle.disposed) {
                 watcherService.unwatchFileChanges(watcherId);

package/src/node/download/file-download-cache.ts

@@ -39,7 +39,7 @@ export class FileDownloadCache {
             downloadInfo.root = encodeURIComponent(downloadInfo.root);
         }
         // expires in 1 minute enough for parallel connections to be connected.
-        downloadInfo.expire = Date.now() + (this.expireTimeInMinutes * 600000);
+        downloadInfo.expire = Date.now() + (this.expireTimeInMinutes * 60 * 1000);
         this.downloads.set(id, downloadInfo);
     }
 

package/src/node/download/file-download-handler.ts

@@ -285,7 +285,6 @@ export class MultiFileDownloadHandler extends FileDownloadHandler {
             }
             const options: PrepareDownloadOptions = { filePath: '', downloadId, remove: true, root: outputRootPath };
             if (tarPaths.length === 1) {
-                // tslint:disable-next-line:whitespace
                 const [outputPath,] = tarPaths;
                 options.filePath = outputPath;
                 await this.prepareDownload(request, response, options);

package/src/node/filesystem-backend-module.ts

@@ -19,7 +19,8 @@ import { ContainerModule, interfaces } from '@theia/core/shared/inversify';
 import { ConnectionHandler, RpcConnectionHandler, ILogger } from '@theia/core/lib/common';
 import { FileSystemWatcherServer, FileSystemWatcherService } from '../common/filesystem-watcher-protocol';
 import { FileSystemWatcherServerClient } from './filesystem-watcher-client';
-import { ParcelFileSystemWatcherService, ParcelFileSystemWatcherServerOptions } from './parcel-watcher/parcel-filesystem-service';
+import { FileSystemWatcherServiceImpl } from './filesystem-watcher-service-impl';
+import { ParcelFileSystemWatcherServerOptions } from './parcel-watcher/parcel-watcher';
 import { NodeFileUploadService } from './upload/node-file-upload-service';
 import { ParcelWatcherOptions } from './parcel-watcher/parcel-options';
 import { DiskFileSystemProvider } from './disk-file-system-provider';
@@ -38,11 +39,11 @@ export const WATCHER_VERBOSE = process.argv.includes('--watcher-verbose');
 
 export const FileSystemWatcherServiceProcessOptions = Symbol('FileSystemWatcherServiceProcessOptions');
 /**
- * Options to control the way the `ParcelFileSystemWatcherService` process is spawned.
+ * Options to control the way the `FileSystemWatcherServiceImpl` process is spawned.
  */
 export interface FileSystemWatcherServiceProcessOptions {
     /**
-     * Path to the script that will run the `ParcelFileSystemWatcherService` in a new process.
+     * Path to the script that will run the `FileSystemWatcherServiceImpl` in a new process.
      */
     entryPoint: string;
 }
@@ -102,7 +103,7 @@ export function bindFileSystemWatcherServer(bind: interfaces.Bind): void {
 export function createParcelFileSystemWatcherService(ctx: interfaces.Context): FileSystemWatcherService {
     const options = ctx.container.get<ParcelFileSystemWatcherServerOptions>(ParcelFileSystemWatcherServerOptions);
     const dispatcher = ctx.container.get<FileSystemWatcherServiceDispatcher>(FileSystemWatcherServiceDispatcher);
-    const server = new ParcelFileSystemWatcherService(options);
+    const server = new FileSystemWatcherServiceImpl(options);
     server.setClient(dispatcher);
     return server;
 }