@theia/filesystem 1.73.0-next.9 → 1.73.0

package/src/browser/file-service.ts

@@ -68,7 +68,7 @@ import { Mutable } from '@theia/core/lib/common/types';
 import { readFileIntoStream } from '../common/io';
 import { FileSystemWatcherErrorHandler } from './filesystem-watcher-error-handler';
 import { FileSystemUtils } from '../common/filesystem-utils';
-import { nls } from '@theia/core';
+import { nls, ILogger } from '@theia/core';
 import { MarkdownString } from '@theia/core/lib/common/markdown-rendering';
 
 export interface FileOperationParticipant {
@@ -305,6 +305,9 @@ export class FileService {
     @inject(FileSystemWatcherErrorHandler)
     protected readonly watcherErrorHandler: FileSystemWatcherErrorHandler;
 
+    @inject(ILogger) @named('filesystem:FileService')
+    protected readonly logger: ILogger;
+
     @postConstruct()
     protected init(): void {
         for (const contribution of this.contributions.getContributions()) {
@@ -581,7 +584,7 @@ export class FileService {
 
                         return await this.toFileStat(provider, childResource, childStat, entries.length, resolveMetadata, recurse);
                     } catch (error) {
-                        console.trace(error);
+                        this.logger.error(error);
 
                         return null; // can happen e.g. due to permission errors
                     }
@@ -590,7 +593,7 @@ export class FileService {
                 // make sure to get rid of null values that signal a failure to resolve a particular entry
                 fileStat.children = resolvedEntries.filter(e => !!e) as FileStat[];
             } catch (error) {
-                console.trace(error);
+                this.logger.error(error);
 
                 fileStat.children = []; // gracefully handle errors, we may not have permissions to read
             }
@@ -615,7 +618,7 @@ export class FileService {
             try {
                 return { stat: await this.doResolveFile(entry.resource, entry.options), success: true };
             } catch (error) {
-                console.trace(error);
+                this.logger.error(error);
 
                 return { stat: undefined, success: false };
             }
@@ -1439,8 +1442,7 @@ export class FileService {
     watch(resource: URI, options: WatchOptions = { recursive: false, excludes: [] }): Disposable {
         const resolvedOptions: WatchOptions = {
             ...options,
-            // always ignore temporary upload files
-            excludes: options.excludes.concat('**/theia_upload_*')
+            excludes: this.resolveWatcherExcludes(resource, options.excludes)
         };
 
         let watchDisposed = false;
@@ -1454,11 +1456,37 @@ export class FileService {
             } else {
                 watchDisposable = disposable;
             }
-        }, error => console.error(error));
+        }, error => this.logger.error(error));
 
         return Disposable.create(() => watchDisposable.dispose());
     }
 
+    /**
+     * Resolve the effective exclude globs for a watcher: the caller-supplied `excludes`, the
+     * always-on temporary-upload exclude, and the user's `files.watcherExclude` preference.
+     *
+     * Applying `files.watcherExclude` here, for every watcher, rather than relying on individual
+     * callers, keeps the number of OS file watches (e.g. inotify watches on Linux) bounded even for
+     * watchers that request `excludes: []` - internal recursive watchers as well as plugin and
+     * language-server watchers created via `vscode.workspace.createFileSystemWatcher`. It also gives
+     * overlapping watchers a consistent set of excludes, so the watcher subsumption in `doWatch` can
+     * collapse them into a single OS watch instead of leaving duplicates that emit duplicate events.
+     */
+    protected resolveWatcherExcludes(resource: URI, excludes: string[]): string[] {
+        const resolved = new Set(excludes);
+        // always ignore temporary upload files
+        resolved.add('**/theia_upload_*');
+        const configured = this.preferences.get('files.watcherExclude', undefined, resource.toString());
+        if (configured) {
+            for (const pattern of Object.keys(configured)) {
+                if (configured[pattern]) {
+                    resolved.add(pattern);
+                }
+            }
+        }
+        return Array.from(resolved);
+    }
+
     async doWatch(resource: URI, options: WatchOptions): Promise<Disposable> {
         const provider = await this.withProvider(resource);
         const key = this.toWatchKey(provider, resource, options);
@@ -2030,7 +2058,7 @@ export class FileService {
                             timeout(participantsTimeout, cancellationTokenSource.token).then(() => cancellationTokenSource.dispose(), () => { /* no-op if cancelled */ })
                         ]);
                     } catch (err) {
-                        console.warn(err);
+                        this.logger.warn(err);
                     }
                 }
             },

package/src/browser/file-tree/file-tree-widget.tsx

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import * as React from '@theia/core/shared/react';
-import { injectable, inject } from '@theia/core/shared/inversify';
+import { injectable, inject, named } from '@theia/core/shared/inversify';
 import { DisposableCollection, Disposable } from '@theia/core/lib/common/disposable';
 import URI from '@theia/core/lib/common/uri';
 import { UriSelection } from '@theia/core/lib/common/selection';
@@ -26,7 +26,7 @@ import { FileTreeModel } from './file-tree-model';
 import { IconThemeService } from '@theia/core/lib/browser/icon-theme-service';
 import { ApplicationShell } from '@theia/core/lib/browser/shell';
 import { FileStat, FileType } from '../../common/files';
-import { isOSX } from '@theia/core';
+import { isOSX, ILogger } from '@theia/core';
 import { FileUploadService } from '../../common/upload/file-upload';
 
 export const FILE_TREE_CLASS = 'theia-FileTree';
@@ -45,6 +45,9 @@ export class FileTreeWidget extends CompressedTreeWidget {
     @inject(IconThemeService)
     protected readonly iconThemeService: IconThemeService;
 
+    @inject(ILogger) @named('filesystem:FileTreeWidget')
+    protected readonly logger: ILogger;
+
     constructor(
         @inject(TreeProps) props: TreeProps,
         @inject(FileTreeModel) override readonly model: FileTreeModel,
@@ -201,7 +204,7 @@ export class FileTreeWidget extends CompressedTreeWidget {
             }
         } catch (e) {
             if (!isCancelled(e)) {
-                console.error(e);
+                this.logger.error(e);
             }
         }
     }

package/src/browser/filesystem-frontend-contribution.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { CorePreferences, nls } from '@theia/core';
+import { CorePreferences, nls, ILogger } from '@theia/core';
 import {
     ApplicationShell,
     CommonCommands,
@@ -35,7 +35,7 @@ import { Command, CommandContribution, CommandRegistry } from '@theia/core/lib/c
 import { Deferred } from '@theia/core/lib/common/promise-util';
 import URI from '@theia/core/lib/common/uri';
 import { environment } from '@theia/core/shared/@theia/application-package/lib/environment';
-import { inject, injectable } from '@theia/core/shared/inversify';
+import { inject, injectable, named } from '@theia/core/shared/inversify';
 import { UserWorkingDirectoryProvider } from '@theia/core/lib/browser/user-working-directory-provider';
 import { FileChangeType, FileChangesEvent, FileOperation } from '../common/files';
 import { FileDialogService, SaveFileDialogProps } from './file-dialog';
@@ -95,6 +95,9 @@ export class FileSystemFrontendContribution implements FrontendApplicationContri
     @inject(UserWorkingDirectoryProvider)
     protected readonly workingDirectory: UserWorkingDirectoryProvider;
 
+    @inject(ILogger) @named('filesystem:FileSystemFrontendContribution')
+    protected readonly logger: ILogger;
+
     protected onDidChangeEditorFileEmitter = new Emitter<{ editor: NavigatableWidget, type: FileChangeType }>();
     readonly onDidChangeEditorFile = this.onDidChangeEditorFileEmitter.event;
 
@@ -171,7 +174,7 @@ export class FileSystemFrontendContribution implements FrontendApplicationContri
             return fileUploadResult;
         } catch (e) {
             if (!isCancelled(e)) {
-                console.error(e);
+                this.logger.error(e);
             }
         }
     }
@@ -227,7 +230,7 @@ export class FileSystemFrontendContribution implements FrontendApplicationContri
             try {
                 await operation();
             } catch (e) {
-                console.error(e);
+                this.logger.error(e);
             }
         });
     }

package/src/browser/location/location-renderer.spec.ts

@@ -174,7 +174,7 @@ describe('LocationListRenderer', () => {
             service.location = location;
             const r = new TestableLocationListRenderer({ model: service as unknown as FileDialogModel, host });
 
-            const selectElement = r.testRenderSelectInput() as React.ReactElement;
+            const selectElement = r.testRenderSelectInput() as React.ReactElement<{ value: string }>;
 
             expect(selectElement.props.value).to.equal(location.toString());
             r.dispose();
@@ -190,7 +190,7 @@ describe('LocationListRenderer', () => {
             const newLocation = URI.fromFilePath('/c:/Users');
             service.location = newLocation;
 
-            const selectElement = r.testRenderSelectInput() as React.ReactElement;
+            const selectElement = r.testRenderSelectInput() as React.ReactElement<{ value: string }>;
 
             expect(selectElement.props.value).to.equal(newLocation.toString());
             r.dispose();

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

@@ -22,7 +22,8 @@
 /* eslint-disable no-null/no-null */
 /* eslint-disable @typescript-eslint/no-shadow */
 
-import { injectable, inject, postConstruct } from '@theia/core/shared/inversify';
+import { injectable, inject, postConstruct, named } from '@theia/core/shared/inversify';
+import { ILogger } from '@theia/core';
 import { basename, dirname, normalize, join } from 'path';
 import { generateUuid } from '@theia/core/lib/common/uuid';
 import * as os from 'os';
@@ -109,6 +110,9 @@ export class DiskFileSystemProvider implements Disposable,
     @inject(EncodingService)
     protected readonly encodingService: EncodingService;
 
+    @inject(ILogger) @named('filesystem:DiskFileSystemProvider')
+    protected readonly logger: ILogger;
+
     @postConstruct()
     protected init(): void {
         this.toDispose.push(this.watcher);
@@ -220,7 +224,7 @@ export class DiskFileSystemProvider implements Disposable,
                     const stat = await this.stat(resource.resolve(child));
                     result.push([child, stat.type]);
                 } catch (error) {
-                    console.trace(error); // ignore errors for individual entries that can arise from permission denied
+                    this.logger.error(error); // ignore errors for individual entries that can arise from permission denied
                 }
             }));
 
@@ -332,7 +336,7 @@ export class DiskFileSystemProvider implements Disposable,
                         // After a successful truncate() the flag can be set to 'r+' which will not truncate.
                         flags = 'r+';
                     } catch (error) {
-                        console.trace(error);
+                        this.logger.error(error);
                     }
                 }
 
@@ -384,7 +388,7 @@ export class DiskFileSystemProvider implements Disposable,
                     // In some exotic setups it is well possible that node fails to sync
                     // In that case we disable flushing and log the error to our logger
                     this.canFlush = false;
-                    console.error(error);
+                    this.logger.error(error);
                 }
             }
 

package/src/node/parcel-watcher/parcel-filesystem-service.ts

@@ -140,6 +140,7 @@ export class ParcelWatcher {
             if (error === WatcherDisposal) {
                 return false;
             }
+            console.error(`Watcher failed to start at "${this.fsPath}":`, error);
             this._dispose();
             this.fireError();
             throw error;
@@ -227,7 +228,33 @@ export class ParcelWatcher {
             this.assertNotDisposed();
         }
         this.assertNotDisposed();
-        const watcher = await this.createWatcher();
+        // This race is specific to Linux/inotify: parcel-watcher's inotify backend walks
+        // the tree and then calls inotify_add_watch on every subdirectory. If a subdirectory
+        // disappears between the walk and the add (common when watching dirs that contain
+        // auto-rotated log/temp folders), the syscall returns ENOENT and parcel-watcher fails
+        // the entire subscribe. Retry a few times: by the next walk the gone-but-not-forgotten
+        // dir is no longer present. Windows (ReadDirectoryChangesW) and macOS (FSEvents) watch
+        // the whole subtree from a single handle on the root and never register per-subdirectory
+        // watches, so they cannot hit this race; the retry is simply a no-op there.
+        let watcher: AsyncSubscription | undefined;
+        let attempt = 0;
+        while (true) {
+            try {
+                watcher = await this.createWatcher();
+                break;
+            } catch (error) {
+                const message: string = (error && error.message) || '';
+                const isTransientEnoent = message.includes('No such file or directory')
+                    && await fsp.stat(this.fsPath).then(() => true, () => false);
+                if (!isTransientEnoent || attempt >= 4) {
+                    throw error;
+                }
+                attempt++;
+                this.assertNotDisposed();
+                await timeout(100 * attempt);
+                this.assertNotDisposed();
+            }
+        }
         this.assertNotDisposed();
         this.debug('STARTED', `disposed=${this.disposed}`);
         // The watcher could be disposed while it was starting, make sure to check for this:

package/src/node/parcel-watcher/parcel-watcher-retry.spec.ts

@@ -0,0 +1,117 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource 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 * as chai from 'chai';
+import * as sinon from 'sinon';
+import * as temp from 'temp';
+import * as fs from '@theia/core/shared/fs-extra';
+import URI from '@theia/core/lib/common/uri';
+import { FileUri } from '@theia/core/lib/node';
+import { ParcelFileSystemWatcherService } from './parcel-filesystem-service';
+
+// We require the *same* module object that the production code imports from, so that
+// stubbing its `subscribe` export is observed by `ParcelWatcher`. The `@theia/core/shared`
+// shim simply re-exports `require('@parcel/watcher')`, so this is the identical reference.
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const parcel = require('@theia/core/shared/@parcel/watcher');
+
+const expect = chai.expect;
+const track = temp.track();
+
+/**
+ * Covers the inotify-tree-race fix in `ParcelWatcher.start()`:
+ *
+ * parcel-watcher walks the directory tree and only then calls `inotify_add_watch`
+ * on each subdirectory. If a subdirectory disappears between the walk and the add
+ * (common when watching dirs that contain rotated logs/temp folders), the syscall
+ * returns ENOENT and parcel-watcher fails the *entire* subscribe. The fix retries
+ * `createWatcher` a few times, but only when (a) the underlying error indicates a
+ * missing path and (b) the watched root itself still exists.
+ */
+describe('parcel-filesystem-watcher transient ENOENT handling', function (): void {
+
+    this.timeout(20000);
+
+    let root: URI;
+    let service: ParcelFileSystemWatcherService;
+    let subscribeStub: sinon.SinonStub | undefined;
+    let consoleErrorStub: sinon.SinonStub;
+    let onError: sinon.SinonStub;
+
+    beforeEach(() => {
+        const tempPath = temp.mkdirSync('parcel-enoent-root');
+        root = FileUri.create(fs.realpathSync(tempPath));
+        // start() now logs the underlying error to stderr on failure; silence it
+        // so the test output stays readable.
+        consoleErrorStub = sinon.stub(console, 'error');
+        service = new ParcelFileSystemWatcherService({ verbose: false });
+        onError = sinon.stub();
+        service.setClient({
+            onDidFilesChanged: () => undefined,
+            onError,
+        });
+    });
+
+    afterEach(() => {
+        subscribeStub?.restore();
+        consoleErrorStub.restore();
+        track.cleanupSync();
+    });
+
+    it('retries when subscribe throws a transient ENOENT and the watched root still exists', async () => {
+        let attempts = 0;
+        subscribeStub = sinon.stub(parcel, 'subscribe').callsFake(async () => {
+            attempts++;
+            if (attempts < 3) {
+                throw new Error('No such file or directory at /tmp/rotated-log');
+            }
+            return { unsubscribe: async () => undefined };
+        });
+
+        await service.watchFileChanges(0, root.toString());
+        // Backoff schedule for two retries: 100 + 200 = 300ms. Leave generous margin.
+        await new Promise(resolve => setTimeout(resolve, 800));
+
+        expect(attempts, 'subscribe should have been retried until it succeeded').to.equal(3);
+        expect(onError.called, 'no error should surface to the client once the retry recovered').to.equal(false);
+    });
+
+    it('does not retry on non-ENOENT errors and surfaces the failure immediately', async () => {
+        subscribeStub = sinon.stub(parcel, 'subscribe').callsFake(async () => {
+            throw new Error('EACCES: permission denied');
+        });
+
+        await service.watchFileChanges(0, root.toString());
+        await new Promise(resolve => setTimeout(resolve, 200));
+
+        expect(subscribeStub.callCount, 'non-transient errors must not trigger any retry').to.equal(1);
+        expect(onError.called, 'error must be reported to the client').to.equal(true);
+    });
+
+    it('gives up after the retry budget is exhausted on persistent ENOENT', async () => {
+        subscribeStub = sinon.stub(parcel, 'subscribe').callsFake(async () => {
+            throw new Error('No such file or directory at /tmp/rotated-log');
+        });
+
+        await service.watchFileChanges(0, root.toString());
+        // Total backoff is 100+200+300+400 = 1000ms; leave a margin for scheduling.
+        await new Promise(resolve => setTimeout(resolve, 1700));
+
+        // Initial attempt + 4 retries = 5 total subscribe calls.
+        expect(subscribeStub.callCount, 'should retry up to the budget then give up').to.equal(5);
+        expect(onError.called, 'error must surface once the retry budget is exhausted').to.equal(true);
+    });
+});

package/src/node/upload/node-file-upload-service.ts

@@ -20,11 +20,16 @@ import os = require('os');
 import express = require('@theia/core/shared/express');
 import fs = require('@theia/core/shared/fs-extra');
 import { BackendApplicationContribution, FileUri } from '@theia/core/lib/node';
-import { injectable } from '@theia/core/shared/inversify';
+import { injectable, inject, named } from '@theia/core/shared/inversify';
 import { HTTP_FILE_UPLOAD_PATH } from '../../common/file-upload';
+import { ILogger } from '@theia/core';
 
 @injectable()
 export class NodeFileUploadService implements BackendApplicationContribution {
+
+    @inject(ILogger) @named('filesystem:NodeFileUploadService')
+    protected readonly logger: ILogger;
+
     private static readonly UPLOAD_DIR = 'theia_upload';
 
     async configure(app: express.Application): Promise<void> {
@@ -32,8 +37,8 @@ export class NodeFileUploadService implements BackendApplicationContribution {
             this.getTemporaryUploadDest(),
             this.getHttpFileUploadPath()
         ]);
-        console.debug(`HTTP file upload URL path: ${http_path}`);
-        console.debug(`Backend file upload cache path: ${dest}`);
+        this.logger.debug(`HTTP file upload URL path: ${http_path}`);
+        this.logger.debug(`Backend file upload cache path: ${dest}`);
         app.post(
             http_path,
             // `multer` handles `multipart/form-data` containing our file to upload.
@@ -72,7 +77,7 @@ export class NodeFileUploadService implements BackendApplicationContribution {
             }
             response.status(200).send(target); // ok
         } catch (error) {
-            console.error(error);
+            this.logger.error(error);
             if (error.message) {
                 // internal server error with error message as response
                 response.status(500).send(error.message);