@theia/filesystem 1.77.0-next.99 → 1.78.0-next.0

package/src/node/archive/archive-extractor.ts

@@ -0,0 +1,350 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH 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 fs from 'fs';
+import * as path from 'path';
+import { Readable } from 'stream';
+import { pipeline } from 'stream/promises';
+import { createGunzip } from 'zlib';
+import * as yauzl from 'yauzl';
+import * as tarStream from 'tar-stream';
+import { inject, injectable, named } from '@theia/core/shared/inversify';
+import { ILogger } from '@theia/core/lib/common/logger';
+
+export type ArchiveFormat = 'zip' | 'tar' | 'tgz';
+
+/** The path of an archive on disk, or the content of an archive. */
+export type ArchiveSource = string | Uint8Array;
+
+export interface ArchiveOptions {
+    /** The format of the archive. Detected from its content if omitted. */
+    format?: ArchiveFormat;
+}
+
+export interface ArchiveReadOptions extends ArchiveOptions {
+    /** Selects the files to read by their path in the archive. All files are read if omitted. */
+    filter?: (entryPath: string) => boolean;
+}
+
+export interface ArchiveEntry {
+    /** The path of the entry relative to the root of the archive, using `/` as separator. */
+    path: string;
+    type: 'file' | 'directory';
+    /** The permission bits of the entry, without the setuid, setgid and sticky bits. */
+    mode?: number;
+}
+
+export interface ArchiveFile extends ArchiveEntry {
+    type: 'file';
+    data: Buffer;
+}
+
+export const ArchiveExtractor = Symbol('ArchiveExtractor');
+/**
+ * Extracts zip, tar and gzipped tar archives.
+ *
+ * Entry paths and links are not trusted: an entry whose path is absolute or leaves the archive root fails the
+ * extraction, and links and other special entries are skipped rather than created, so that nothing can be
+ * written or exposed outside of the destination. The size of the extracted content is not limited.
+ */
+export interface ArchiveExtractor {
+    /**
+     * Extracts the archive into the destination directory, creating it if needed.
+     * @returns the extracted files and directories.
+     */
+    extract(source: ArchiveSource, destination: string, options?: ArchiveOptions): Promise<ArchiveEntry[]>;
+    /**
+     * Reads the content of the files in the archive without writing anything to disk.
+     */
+    readFiles(source: ArchiveSource, options?: ArchiveReadOptions): Promise<ArchiveFile[]>;
+}
+
+/** An entry as reported by the reader of an archive format, before its path is validated. */
+interface RawArchiveEntry {
+    name: string;
+    kind: 'file' | 'directory' | 'unsupported';
+    mode?: number;
+    /** Opens the content of a file entry. Entries that are not opened are discarded. */
+    open(): Promise<Readable>;
+}
+
+type RawArchiveEntryVisitor = (entry: RawArchiveEntry) => Promise<void>;
+
+const S_IFMT = 0o170000;
+const S_IFREG = 0o100000;
+const S_IFDIR = 0o040000;
+const PERMISSION_BITS = 0o777;
+
+/**
+ * Existing links are rejected before a file is opened; `O_NOFOLLOW` additionally guards against a link created in between
+ * where the platform supports it, which Windows does not.
+ */
+const WRITE_FLAGS = fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_TRUNC | (fs.constants.O_NOFOLLOW ?? 0);
+
+@injectable()
+export class ArchiveExtractorImpl implements ArchiveExtractor {
+
+    /** Not available to instances created without dependency injection, which report skipped entries on the console. */
+    @inject(ILogger) @named('filesystem:ArchiveExtractorImpl')
+    protected readonly logger?: ILogger;
+
+    async extract(source: ArchiveSource, destination: string, options: ArchiveOptions = {}): Promise<ArchiveEntry[]> {
+        await fs.promises.mkdir(destination, { recursive: true });
+        const root = await fs.promises.realpath(destination);
+        const verifiedDirectories = new Set<string>([root]);
+        const entries: ArchiveEntry[] = [];
+        const skipped: string[] = [];
+        await this.readEntries(source, options.format, async entry => {
+            const entryPath = this.toEntryPath(entry.name);
+            if (!entryPath) {
+                return;
+            }
+            if (entry.kind === 'unsupported') {
+                skipped.push(entryPath);
+                return;
+            }
+            const target = path.join(root, ...entryPath.split('/'));
+            if (entry.kind === 'directory') {
+                await this.createDirectory(root, target, verifiedDirectories);
+                entries.push({ path: entryPath, type: 'directory', mode: entry.mode });
+            } else {
+                await this.createDirectory(root, path.dirname(target), verifiedDirectories);
+                await this.assertNoLink(root, target);
+                await this.writeFile(target, await entry.open(), entry.mode);
+                entries.push({ path: entryPath, type: 'file', mode: entry.mode });
+            }
+        });
+        this.reportSkipped(source, skipped);
+        return entries;
+    }
+
+    async readFiles(source: ArchiveSource, options: ArchiveReadOptions = {}): Promise<ArchiveFile[]> {
+        const files: ArchiveFile[] = [];
+        const skipped: string[] = [];
+        await this.readEntries(source, options.format, async entry => {
+            const entryPath = this.toEntryPath(entry.name);
+            if (entryPath && entry.kind === 'unsupported') {
+                skipped.push(entryPath);
+            }
+            if (!entryPath || entry.kind !== 'file' || (options.filter && !options.filter(entryPath))) {
+                return;
+            }
+            const chunks: Buffer[] = [];
+            for await (const chunk of await entry.open()) {
+                chunks.push(chunk);
+            }
+            files.push({ path: entryPath, type: 'file', mode: entry.mode, data: Buffer.concat(chunks) });
+        });
+        this.reportSkipped(source, skipped);
+        return files;
+    }
+
+    protected async readEntries(source: ArchiveSource, format: ArchiveFormat | undefined, visit: RawArchiveEntryVisitor): Promise<void> {
+        switch (format ?? await this.detectFormat(source)) {
+            case 'zip':
+                return this.readZipEntries(source, visit);
+            case 'tar':
+                return this.readTarEntries(source, false, visit);
+            case 'tgz':
+                return this.readTarEntries(source, true, visit);
+        }
+    }
+
+    /**
+     * Detects the format of an archive from its first bytes.
+     */
+    protected async detectFormat(source: ArchiveSource): Promise<ArchiveFormat> {
+        const header = await this.readHeader(source, 512);
+        if (header.length >= 4 && header[0] === 0x50 && header[1] === 0x4b && ((header[2] === 0x03 && header[3] === 0x04) || (header[2] === 0x05 && header[3] === 0x06))) {
+            return 'zip';
+        }
+        if (header.length >= 2 && header[0] === 0x1f && header[1] === 0x8b) {
+            return 'tgz';
+        }
+        if (header.length >= 262 && header.toString('latin1', 257, 262) === 'ustar') {
+            return 'tar';
+        }
+        throw new Error(`Unsupported archive format${typeof source === 'string' ? `: ${source}` : ''}`);
+    }
+
+    protected async readHeader(source: ArchiveSource, length: number): Promise<Buffer> {
+        if (typeof source !== 'string') {
+            return Buffer.from(source.subarray(0, length));
+        }
+        const handle = await fs.promises.open(source, 'r');
+        try {
+            const buffer = Buffer.alloc(length);
+            const { bytesRead } = await handle.read(buffer, 0, length, 0);
+            return buffer.subarray(0, bytesRead);
+        } finally {
+            await handle.close();
+        }
+    }
+
+    protected async readZipEntries(source: ArchiveSource, visit: RawArchiveEntryVisitor): Promise<void> {
+        const zipFile = typeof source === 'string'
+            ? await yauzl.openPromise(source)
+            : await yauzl.fromBufferPromise(Buffer.from(source));
+        try {
+            for await (const entry of zipFile.eachEntry()) {
+                // The upper 16 bits hold the Unix mode if the archive was created on a Unix system, and are 0 otherwise.
+                const unixMode = entry.externalFileAttributes >>> 16;
+                const fileType = unixMode & S_IFMT;
+                let kind: RawArchiveEntry['kind'];
+                if (entry.fileName.endsWith('/') || fileType === S_IFDIR) {
+                    kind = 'directory';
+                } else if (fileType === 0 || fileType === S_IFREG) {
+                    kind = 'file';
+                } else {
+                    kind = 'unsupported';
+                }
+                await visit({
+                    name: entry.fileName,
+                    kind,
+                    mode: this.toMode(unixMode),
+                    open: () => zipFile.openReadStreamPromise(entry)
+                });
+            }
+        } finally {
+            if (zipFile.isOpen) {
+                zipFile.close();
+            }
+        }
+    }
+
+    protected async readTarEntries(source: ArchiveSource, gzipped: boolean, visit: RawArchiveEntryVisitor): Promise<void> {
+        const input = typeof source === 'string' ? fs.createReadStream(source) : Readable.from([Buffer.from(source)]);
+        const extract = tarStream.extract();
+        const streams: NodeJS.ReadWriteStream[] = gzipped ? [createGunzip()] : [];
+        // Resolves with the error instead of rejecting, so that a failure is not unhandled while entries are visited.
+        const feeding = pipeline([input, ...streams, extract as unknown as NodeJS.WritableStream]).then(() => undefined, (reason: unknown) => reason);
+        try {
+            for await (const entry of extract) {
+                const header = entry.header;
+                let kind: RawArchiveEntry['kind'];
+                if (header.type === 'file' || header.type === 'contiguous-file') {
+                    kind = 'file';
+                } else if (header.type === 'directory') {
+                    kind = 'directory';
+                } else {
+                    kind = 'unsupported';
+                }
+                let consumed = false;
+                await visit({
+                    name: header.name,
+                    kind,
+                    mode: this.toMode(header.mode),
+                    open: async () => {
+                        consumed = true;
+                        // Entries are not Node streams: Node's `pipeline` would wait forever for an entry that a failing archive
+                        // already destroyed, while a stream created from the entry fails.
+                        return Readable.from(entry);
+                    }
+                });
+                if (!consumed) {
+                    entry.resume();
+                }
+            }
+        } catch (error) {
+            input.destroy();
+            await feeding;
+            throw error;
+        }
+        const feedError = await feeding;
+        if (feedError) {
+            throw feedError;
+        }
+    }
+
+    /**
+     * Normalizes the name of an entry to a relative path with `/` as separator.
+     * @returns `undefined` for the archive root.
+     * @throws if the name is absolute or leaves the archive root.
+     */
+    protected toEntryPath(name: string): string | undefined {
+        const normalized = name.replace(/\\/g, '/');
+        if (normalized.startsWith('/') || /^[a-zA-Z]:/.test(normalized)) {
+            throw new Error(`Archive entry has an absolute path: ${name}`);
+        }
+        const segments = normalized.split('/').filter(segment => segment && segment !== '.');
+        if (segments.includes('..')) {
+            throw new Error(`Archive entry leaves the extraction directory: ${name}`);
+        }
+        return segments.length > 0 ? segments.join('/') : undefined;
+    }
+
+    protected toMode(mode: number | undefined): number | undefined {
+        const permissions = (mode ?? 0) & PERMISSION_BITS;
+        return permissions || undefined;
+    }
+
+    /**
+     * Creates a directory below the root one segment at a time and refuses to descend into an existing entry that is not
+     * a directory, so that nothing is created or written through a link that already existed in the destination.
+     */
+    protected async createDirectory(root: string, directory: string, verifiedDirectories: Set<string>): Promise<void> {
+        let current = root;
+        for (const segment of path.relative(root, directory).split(path.sep)) {
+            current = path.join(current, segment);
+            if (verifiedDirectories.has(current)) {
+                continue;
+            }
+            try {
+                await fs.promises.mkdir(current);
+            } catch (error) {
+                if ((error as NodeJS.ErrnoException).code !== 'EEXIST') {
+                    throw error;
+                }
+                if (!(await fs.promises.lstat(current)).isDirectory()) {
+                    throw new Error(`Archive entry leaves the extraction directory: ${path.relative(root, current)}`);
+                }
+            }
+            verifiedDirectories.add(current);
+        }
+    }
+
+    /**
+     * Rejects writing a file over an existing link or special file, which could point outside of the destination.
+     */
+    protected async assertNoLink(root: string, target: string): Promise<void> {
+        const existing = await fs.promises.lstat(target).catch((error: NodeJS.ErrnoException) => {
+            if (error.code === 'ENOENT') {
+                return undefined;
+            }
+            throw error;
+        });
+        if (existing && !existing.isFile()) {
+            throw new Error(`Archive entry would be written through a link or special file: ${path.relative(root, target)}`);
+        }
+    }
+
+    protected async writeFile(target: string, content: Readable, mode: number | undefined): Promise<void> {
+        const handle = await fs.promises.open(target, WRITE_FLAGS, mode ?? 0o666);
+        await pipeline(content, handle.createWriteStream());
+    }
+
+    protected reportSkipped(source: ArchiveSource, skipped: string[]): void {
+        if (skipped.length > 0) {
+            const message = `Skipped ${skipped.length} link or special entries of archive${typeof source === 'string' ? ` ${source}` : ''}: ${skipped.join(', ')}`;
+            if (this.logger) {
+                this.logger.warn(message);
+            } else {
+                // eslint-disable-next-line @theia/named-logger-check
+                console.warn(message);
+            }
+        }
+    }
+}

package/src/node/archive/test/test-archives.ts

@@ -0,0 +1,117 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH 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 { crc32, gzipSync } from 'zlib';
+import * as tarStream from 'tar-stream';
+
+export interface TestZipEntry {
+    name: string;
+    /** The Unix mode including the file type bits, e.g. `0o100644` for a file or `0o120777` for a symlink. */
+    mode?: number;
+    data?: string | Uint8Array;
+}
+
+/**
+ * Builds a zip archive with stored entries. Unlike archiving libraries, it writes names and modes as given,
+ * so that it can produce the hostile archives the extractor has to handle.
+ */
+export function createTestZip(entries: TestZipEntry[]): Buffer {
+    const localParts: Buffer[] = [];
+    const centralParts: Buffer[] = [];
+    let offset = 0;
+    for (const entry of entries) {
+        const name = Buffer.from(entry.name, 'utf8');
+        const data = typeof entry.data === 'string' || entry.data === undefined ? Buffer.from(entry.data ?? '', 'utf8') : Buffer.from(entry.data);
+        const checksum = crc32(data);
+
+        const local = Buffer.alloc(30);
+        local.writeUInt32LE(0x04034b50, 0);
+        local.writeUInt16LE(20, 4);
+        local.writeUInt16LE(0x0800, 6);
+        local.writeUInt16LE(0, 8);
+        local.writeUInt16LE(0, 10);
+        local.writeUInt16LE(0x21, 12);
+        local.writeUInt32LE(checksum, 14);
+        local.writeUInt32LE(data.length, 18);
+        local.writeUInt32LE(data.length, 22);
+        local.writeUInt16LE(name.length, 26);
+        local.writeUInt16LE(0, 28);
+        localParts.push(local, name, data);
+
+        const central = Buffer.alloc(46);
+        central.writeUInt32LE(0x02014b50, 0);
+        // Made by Unix, so that the upper 16 bits of the external attributes hold the mode.
+        central.writeUInt16LE((3 << 8) | 20, 4);
+        central.writeUInt16LE(20, 6);
+        central.writeUInt16LE(0x0800, 8);
+        central.writeUInt16LE(0, 10);
+        central.writeUInt16LE(0, 12);
+        central.writeUInt16LE(0x21, 14);
+        central.writeUInt32LE(checksum, 16);
+        central.writeUInt32LE(data.length, 20);
+        central.writeUInt32LE(data.length, 24);
+        central.writeUInt16LE(name.length, 28);
+        central.writeUInt16LE(0, 30);
+        central.writeUInt16LE(0, 32);
+        central.writeUInt16LE(0, 34);
+        central.writeUInt16LE(0, 36);
+        central.writeUInt32LE(((entry.mode ?? 0o100644) << 16) >>> 0, 38);
+        central.writeUInt32LE(offset, 42);
+        centralParts.push(central, name);
+
+        offset += local.length + name.length + data.length;
+    }
+    const centralDirectory = Buffer.concat(centralParts);
+    const end = Buffer.alloc(22);
+    end.writeUInt32LE(0x06054b50, 0);
+    end.writeUInt16LE(0, 4);
+    end.writeUInt16LE(0, 6);
+    end.writeUInt16LE(entries.length, 8);
+    end.writeUInt16LE(entries.length, 10);
+    end.writeUInt32LE(centralDirectory.length, 12);
+    end.writeUInt32LE(offset, 16);
+    end.writeUInt16LE(0, 20);
+    return Buffer.concat([...localParts, centralDirectory, end]);
+}
+
+export interface TestTarEntry {
+    name: string;
+    type?: 'file' | 'directory' | 'symlink' | 'link' | 'fifo';
+    mode?: number;
+    linkname?: string;
+    data?: string | Uint8Array;
+}
+
+export async function createTestTar(entries: TestTarEntry[], gzip = false): Promise<Buffer> {
+    const pack = tarStream.pack();
+    const chunks: Buffer[] = [];
+    const collected = (async () => {
+        for await (const chunk of pack) {
+            chunks.push(chunk as Buffer);
+        }
+    })();
+    for (const entry of entries) {
+        const type = entry.type ?? 'file';
+        await new Promise<void>((resolve, reject) => {
+            const header = { name: entry.name, type, mode: entry.mode, linkname: entry.linkname };
+            pack.entry(header, entry.data ?? '', error => error ? reject(error) : resolve());
+        });
+    }
+    pack.finalize();
+    await collected;
+    const tar = Buffer.concat(chunks);
+    return gzip ? gzipSync(tar) : tar;
+}

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

@@ -27,9 +27,9 @@ import * as os from 'os';
 import { join } from 'path';
 import * as temp from 'temp';
 import { generateUuid } from '@theia/core/lib/common/uuid';
-import { FilePermission, FileSystemProviderCapabilities, FileSystemProviderError, FileSystemProviderErrorCode } from '../common/files';
-import { DiskFileSystemProvider } from './disk-file-system-provider';
-import { bindFileSystemWatcherServer } from './filesystem-backend-module';
+import { FilePermission, FileSystemProviderCapabilities, FileSystemProviderError, FileSystemProviderErrorCode } from '../common/files.js';
+import { DiskFileSystemProvider } from './disk-file-system-provider.js';
+import { bindFileSystemWatcherServer } from './filesystem-backend-module.js';
 
 const tracked = temp.track();
 

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

@@ -56,17 +56,18 @@ import {
     FileChange,
     WatchOptions,
     FileUpdateOptions, FileUpdateResult, FileReadStreamOptions, FilePermission
-} from '../common/files';
-import { FileSystemWatcherServer } from '../common/filesystem-watcher-protocol';
-import trash = require('trash');
+} from '../common/files.js';
+import { FileSystemWatcherServer } from '../common/filesystem-watcher-protocol.js';
+import trash from 'trash';
 import { TextDocumentContentChangeEvent } from '@theia/core/shared/vscode-languageserver-protocol';
 import { TextDocument } from 'vscode-languageserver-textdocument';
 import { EncodingService } from '@theia/core/lib/common/encoding-service';
 import { BinaryBuffer } from '@theia/core/lib/common/buffer';
 import { ReadableStreamEvents, newWriteableStream } from '@theia/core/lib/common/stream';
 import { CancellationToken } from '@theia/core/lib/common/cancellation';
-import { readFileIntoStream } from '../common/io';
-import { Mode } from 'stat-mode';
+import { readFileIntoStream } from '../common/io.js';
+// A CommonJS module whose exports cannot be detected statically, so it is imported as a whole.
+import statMode from 'stat-mode';
 
 export namespace DiskFileSystemProvider {
     export interface StatAndLink {
@@ -156,7 +157,7 @@ export class DiskFileSystemProvider implements Disposable,
     async stat(resource: URI): Promise<Stat> {
         try {
             const { stat, symbolicLink } = await this.statLink(this.toFilePath(resource)); // cannot use fs.stat() here to support links properly
-            const mode = new Mode(stat);
+            const mode = new statMode.Mode(stat);
             return {
                 type: this.toType(stat, symbolicLink),
                 ctime: stat.birthtime.getTime(), // intentionally not using ctime here, we want the creation time

package/src/node/download/directory-archiver.spec.ts

@@ -20,7 +20,7 @@ import * as temp from 'temp';
 import { extract } from 'tar-fs';
 import { expect } from 'chai';
 import URI from '@theia/core/lib/common/uri';
-import { MockDirectoryArchiver } from './test/mock-directory-archiver';
+import { MockDirectoryArchiver } from './test/mock-directory-archiver.js';
 import { FileUri } from '@theia/core/lib/common/file-uri';
 
 const track = temp.track();

package/src/node/download/file-download-backend-module.ts

@@ -16,10 +16,10 @@
 
 import { ContainerModule } from '@theia/core/shared/inversify';
 import { BackendApplicationContribution } from '@theia/core/lib/node/backend-application';
-import { FileDownloadEndpoint } from './file-download-endpoint';
-import { FileDownloadHandler, SingleFileDownloadHandler, MultiFileDownloadHandler, DownloadLinkHandler } from './file-download-handler';
-import { DirectoryArchiver } from './directory-archiver';
-import { FileDownloadCache } from './file-download-cache';
+import { FileDownloadEndpoint } from './file-download-endpoint.js';
+import { FileDownloadHandler, SingleFileDownloadHandler, MultiFileDownloadHandler, DownloadLinkHandler } from './file-download-handler.js';
+import { DirectoryArchiver } from './directory-archiver.js';
+import { FileDownloadCache } from './file-download-cache.js';
 
 export default new ContainerModule(bind => {
     bind(FileDownloadEndpoint).toSelf().inSingletonScope();

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

@@ -17,12 +17,13 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { injectable, inject, named } from '@theia/core/shared/inversify';
-import { json } from 'body-parser';
+// A CommonJS module whose exports cannot be detected statically, so it is imported as a whole.
+import bodyParser from 'body-parser';
 import { Application, Router, RequestHandler } from '@theia/core/shared/express';
 import { BackendApplicationContribution } from '@theia/core/lib/node/backend-application';
 import { HttpConnectionValidator } from '@theia/core/lib/node';
 import { FileUri } from '@theia/core/lib/common/file-uri';
-import { FileDownloadHandler } from './file-download-handler';
+import { FileDownloadHandler } from './file-download-handler.js';
 
 @injectable()
 export class FileDownloadEndpoint implements BackendApplicationContribution {
@@ -52,7 +53,7 @@ export class FileDownloadEndpoint implements BackendApplicationContribution {
         router.get('/', (request, response) => this.singleFileDownloadHandler.handle(request, response));
         router.put('/', (request, response) => this.multiFileDownloadHandler.handle(request, response));
         // Content-Type: application/json
-        app.use(json());
+        app.use(bodyParser.json());
         app.use(FileDownloadEndpoint.PATH, guard, router);
         app.get('/file', guard, (request, response) => {
             const uri = new URL(request.url, 'http://localhost').search.slice(1);

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

@@ -25,9 +25,9 @@ import URI from '@theia/core/lib/common/uri';
 import { isEmpty } from '@theia/core/lib/common/objects';
 import { ILogger } from '@theia/core/lib/common/logger';
 import { FileUri } from '@theia/core/lib/common/file-uri';
-import { DirectoryArchiver } from './directory-archiver';
-import { FileDownloadData } from '../../common/download/file-download';
-import { FileDownloadCache, DownloadStorageItem } from './file-download-cache';
+import { DirectoryArchiver } from './directory-archiver.js';
+import { FileDownloadData } from '../../common/download/file-download.js';
+import { FileDownloadCache, DownloadStorageItem } from './file-download-cache.js';
 
 interface PrepareDownloadOptions {
     filePath: string;

package/src/node/download/test/mock-directory-archiver.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { DirectoryArchiver } from '../directory-archiver';
+import { DirectoryArchiver } from '../directory-archiver.js';
 import URI from '@theia/core/lib/common/uri';
 
 export class MockDirectoryArchiver extends DirectoryArchiver {

package/src/node/file-change-collection.spec.ts

@@ -16,8 +16,8 @@
 
 import * as assert from 'assert';
 import { FileUri } from '@theia/core/lib/common/file-uri';
-import { FileChangeCollection } from './file-change-collection';
-import { FileChangeType } from '../common/files';
+import { FileChangeCollection } from './file-change-collection.js';
+import { FileChangeType } from '../common/files.js';
 
 describe('FileChangeCollection', () => {
 

package/src/node/file-change-collection.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { FileChange, FileChangeType } from '../common/filesystem-watcher-protocol';
+import { FileChange, FileChangeType } from '../common/filesystem-watcher-protocol.js';
 
 /**
  * A file change collection guarantees that only one change is reported for each URI.