@theia/dev-container 1.46.0-next.241

package/src/electron-browser/dev-container-frontend-module.ts

@@ -0,0 +1,40 @@
+// *****************************************************************************
+// Copyright (C) 2024 Typefox 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 { ContainerModule } from '@theia/core/shared/inversify';
+import { RemoteRegistryContribution } from '@theia/remote/lib/electron-browser/remote-registry-contribution';
+import { RemoteContainerConnectionProvider, RemoteContainerConnectionProviderPath } from '../electron-common/remote-container-connection-provider';
+import { ContainerConnectionContribution } from './container-connection-contribution';
+import { ServiceConnectionProvider } from '@theia/core/lib/browser/messaging/service-connection-provider';
+import { ContainerOutputProvider } from './container-output-provider';
+import { ContainerInfoContribution } from './container-info-contribution';
+import { FrontendApplicationContribution } from '@theia/core/lib/browser';
+import { WorkspaceOpenHandlerContribution } from '@theia/workspace/lib/browser/workspace-service';
+
+export default new ContainerModule(bind => {
+    bind(ContainerConnectionContribution).toSelf().inSingletonScope();
+    bind(RemoteRegistryContribution).toService(ContainerConnectionContribution);
+    bind(WorkspaceOpenHandlerContribution).toService(ContainerConnectionContribution);
+
+    bind(ContainerOutputProvider).toSelf().inSingletonScope();
+
+    bind(RemoteContainerConnectionProvider).toDynamicValue(ctx => {
+        const outputProvider = ctx.container.get(ContainerOutputProvider);
+        return ServiceConnectionProvider.createLocalProxy<RemoteContainerConnectionProvider>(ctx.container, RemoteContainerConnectionProviderPath, outputProvider);
+    }).inSingletonScope();
+
+    bind(ContainerInfoContribution).toSelf().inSingletonScope();
+    bind(FrontendApplicationContribution).toService(ContainerInfoContribution);
+});

package/src/electron-common/container-output-provider.ts

@@ -0,0 +1,19 @@
+// *****************************************************************************
+// Copyright (C) 2024 Typefox 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
+// *****************************************************************************
+
+export interface ContainerOutputProvider {
+    onRemoteOutput(output: string): void;
+}

package/src/electron-common/dev-container-workspaces.ts

@@ -0,0 +1,18 @@
+// *****************************************************************************
+// Copyright (C) 2024 Typefox 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
+// *****************************************************************************
+
+export const DEV_CONTAINER_WORKSPACE_SCHEME = 'devcontainer';
+export const DEV_CONTAINER_PATH_QUERY = 'containerfile';

package/src/electron-common/remote-container-connection-provider.ts

@@ -0,0 +1,52 @@
+// *****************************************************************************
+// Copyright (C) 2024 Typefox 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 { RpcServer } from '@theia/core';
+import { ContainerOutputProvider } from './container-output-provider';
+import type { ContainerInspectInfo } from 'dockerode';
+
+// *****************************************************************************
+export const RemoteContainerConnectionProviderPath = '/remote/container';
+
+export const RemoteContainerConnectionProvider = Symbol('RemoteContainerConnectionProvider');
+
+export interface ContainerConnectionOptions {
+    nodeDownloadTemplate?: string;
+    lastContainerInfo?: LastContainerInfo
+    devcontainerFile: string;
+    workspaceUri?: string;
+}
+
+export interface LastContainerInfo {
+    id: string;
+    lastUsed: number;
+}
+
+export interface ContainerConnectionResult {
+    port: string;
+    workspacePath: string;
+    containerId: string;
+}
+
+export interface DevContainerFile {
+    name: string;
+    path: string;
+}
+
+export interface RemoteContainerConnectionProvider extends RpcServer<ContainerOutputProvider> {
+    connectToContainer(options: ContainerConnectionOptions): Promise<ContainerConnectionResult>;
+    getDevContainerFiles(workspacePath: string): Promise<DevContainerFile[]>;
+    getCurrentContainerInfo(port: number): Promise<ContainerInspectInfo | undefined>;
+}

package/src/electron-node/dev-container-backend-module.ts

@@ -0,0 +1,63 @@
+// *****************************************************************************
+// Copyright (C) 2024 Typefox 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 { ContainerModule } from '@theia/core/shared/inversify';
+import { ConnectionContainerModule } from '@theia/core/lib/node/messaging/connection-container-module';
+import { DevContainerConnectionProvider } from './remote-container-connection-provider';
+import { RemoteContainerConnectionProvider, RemoteContainerConnectionProviderPath } from '../electron-common/remote-container-connection-provider';
+import { ContainerCreationContribution, DockerContainerService } from './docker-container-service';
+import { bindContributionProvider, ConnectionHandler, RpcConnectionHandler } from '@theia/core';
+import { registerContainerCreationContributions } from './devcontainer-contributions/main-container-creation-contributions';
+import { DevContainerFileService } from './dev-container-file-service';
+import { ContainerOutputProvider } from '../electron-common/container-output-provider';
+import { ExtensionsContribution, registerTheiaStartOptionsContributions, SettingsContribution } from './devcontainer-contributions/cli-enhancing-creation-contributions';
+import { RemoteCliContribution } from '@theia/core/lib/node/remote/remote-cli-contribution';
+import { ProfileFileModificationContribution } from './devcontainer-contributions/profile-file-modification-contribution';
+import { DevContainerWorkspaceHandler } from './dev-container-workspace-handler';
+import { WorkspaceHandlerContribution } from '@theia/workspace/lib/node/default-workspace-server';
+
+export const remoteConnectionModule = ConnectionContainerModule.create(({ bind, bindBackendService }) => {
+    bindContributionProvider(bind, ContainerCreationContribution);
+    registerContainerCreationContributions(bind);
+    registerTheiaStartOptionsContributions(bind);
+    bind(ProfileFileModificationContribution).toSelf().inSingletonScope();
+    bind(ContainerCreationContribution).toService(ProfileFileModificationContribution);
+
+    bind(DevContainerConnectionProvider).toSelf().inSingletonScope();
+    bind(RemoteContainerConnectionProvider).toService(DevContainerConnectionProvider);
+    bind(ConnectionHandler).toDynamicValue(ctx =>
+        new RpcConnectionHandler<ContainerOutputProvider>(RemoteContainerConnectionProviderPath, client => {
+            const server = ctx.container.get<RemoteContainerConnectionProvider>(RemoteContainerConnectionProvider);
+            server.setClient(client);
+            client.onDidCloseConnection(() => server.dispose());
+            return server;
+        }));
+});
+
+export default new ContainerModule((bind, unbind, isBound, rebind) => {
+    bind(DockerContainerService).toSelf().inSingletonScope();
+    bind(ConnectionContainerModule).toConstantValue(remoteConnectionModule);
+
+    bind(DevContainerFileService).toSelf().inSingletonScope();
+
+    bind(ExtensionsContribution).toSelf().inSingletonScope();
+    bind(SettingsContribution).toSelf().inSingletonScope();
+    bind(RemoteCliContribution).toService(ExtensionsContribution);
+    bind(RemoteCliContribution).toService(SettingsContribution);
+
+    bind(DevContainerWorkspaceHandler).toSelf().inSingletonScope();
+    bind(WorkspaceHandlerContribution).toService(DevContainerWorkspaceHandler);
+});

package/src/electron-node/dev-container-file-service.ts

@@ -0,0 +1,67 @@
+// *****************************************************************************
+// Copyright (C) 2024 Typefox 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 { inject, injectable } from '@theia/core/shared/inversify';
+import { WorkspaceServer } from '@theia/workspace/lib/common';
+import { DevContainerFile } from '../electron-common/remote-container-connection-provider';
+import { DevContainerConfiguration } from './devcontainer-file';
+import { parse } from 'jsonc-parser';
+import * as fs from '@theia/core/shared/fs-extra';
+import { Path, URI } from '@theia/core';
+
+@injectable()
+export class DevContainerFileService {
+
+    @inject(WorkspaceServer)
+    protected readonly workspaceServer: WorkspaceServer;
+
+    async getConfiguration(path: string): Promise<DevContainerConfiguration> {
+        const configuration: DevContainerConfiguration = parse(await fs.readFile(path, 'utf-8').catch(() => '0')) as DevContainerConfiguration;
+        if (!configuration) {
+            throw new Error(`devcontainer file ${path} could not be parsed`);
+        }
+
+        configuration.location = path;
+        return configuration;
+    }
+
+    async getAvailableFiles(workspace: string): Promise<DevContainerFile[]> {
+        const devcontainerPath = new URI(workspace).path.join('.devcontainer').fsPath();
+
+        return (await this.searchForDevontainerJsonFiles(devcontainerPath, 1)).map(file => ({
+            name: parse(fs.readFileSync(file, 'utf-8')).name ?? 'devcontainer',
+            path: file
+        }));
+
+    }
+
+    protected async searchForDevontainerJsonFiles(directory: string, depth: number): Promise<string[]> {
+        if (depth < 0 || !await fs.pathExists(directory)) {
+            return [];
+        }
+        const filesPaths = (await fs.readdir(directory)).map(file => new Path(directory).join(file).fsPath());
+
+        const devcontainerFiles = [];
+        for (const file of filesPaths) {
+            if (file.endsWith('devcontainer.json')) {
+                devcontainerFiles.push(file);
+            } else if ((await fs.stat(file)).isDirectory()) {
+                devcontainerFiles.push(...await this.searchForDevontainerJsonFiles(file, depth - 1));
+            }
+        }
+        return devcontainerFiles;
+    }
+}

package/src/electron-node/dev-container-workspace-handler.ts

@@ -0,0 +1,33 @@
+// *****************************************************************************
+// Copyright (C) 2024 Typefox 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 { URI } from '@theia/core';
+import * as fs from '@theia/core/shared/fs-extra';
+import { injectable } from '@theia/core/shared/inversify';
+import { WorkspaceHandlerContribution } from '@theia/workspace/lib/node/default-workspace-server';
+import { DEV_CONTAINER_PATH_QUERY, DEV_CONTAINER_WORKSPACE_SCHEME } from '../electron-common/dev-container-workspaces';
+
+@injectable()
+export class DevContainerWorkspaceHandler implements WorkspaceHandlerContribution {
+
+    canHandle(uri: URI): boolean {
+        return uri.scheme === DEV_CONTAINER_WORKSPACE_SCHEME;
+    }
+
+    async workspaceStillExists(uri: URI): Promise<boolean> {
+        const devcontainerFile = new URLSearchParams(uri.query).get(DEV_CONTAINER_PATH_QUERY);
+        return await fs.pathExists(uri.path.fsPath()) && !!devcontainerFile && fs.pathExists(devcontainerFile);
+    }
+}

package/src/electron-node/devcontainer-contributions/cli-enhancing-creation-contributions.ts

@@ -0,0 +1,68 @@
+// *****************************************************************************
+// Copyright (C) 2024 Typefox 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 { RemoteCliContext, RemoteCliContribution } from '@theia/core/lib/node/remote/remote-cli-contribution';
+import { ContainerCreationContribution } from '../docker-container-service';
+import * as Docker from 'dockerode';
+import { DevContainerConfiguration, } from '../devcontainer-file';
+import { injectable, interfaces } from '@theia/core/shared/inversify';
+
+export function registerTheiaStartOptionsContributions(bind: interfaces.Bind): void {
+    bind(ContainerCreationContribution).toService(ExtensionsContribution);
+    bind(ContainerCreationContribution).toService(SettingsContribution);
+}
+
+@injectable()
+export class ExtensionsContribution implements RemoteCliContribution, ContainerCreationContribution {
+    protected currentConfig: DevContainerConfiguration | undefined;
+
+    enhanceArgs(context: RemoteCliContext): string[] {
+        if (!this.currentConfig) {
+            return [];
+        }
+        const extensions = [
+            ...(this.currentConfig.extensions ?? []),
+            ...(this.currentConfig.customizations?.vscode?.extensions ?? [])
+        ];
+        this.currentConfig = undefined;
+        return extensions?.map(extension => `--install-plugin=${extension}`);
+    }
+
+    async handleContainerCreation(createOptions: Docker.ContainerCreateOptions, containerConfig: DevContainerConfiguration): Promise<void> {
+        this.currentConfig = containerConfig;
+    }
+}
+
+@injectable()
+export class SettingsContribution implements RemoteCliContribution, ContainerCreationContribution {
+    protected currentConfig: DevContainerConfiguration | undefined;
+
+    enhanceArgs(context: RemoteCliContext): string[] {
+        if (!this.currentConfig) {
+            return [];
+        }
+        const settings = {
+            ...(this.currentConfig.settings ?? {}),
+            ...(this.currentConfig.customizations?.vscode?.settings ?? [])
+        };
+        this.currentConfig = undefined;
+        return Object.entries(settings).map(([key, value]) => `--set-preference=${key}=${JSON.stringify(value)}`) ?? [];
+    }
+
+    async handleContainerCreation(createOptions: Docker.ContainerCreateOptions, containerConfig: DevContainerConfiguration): Promise<void> {
+        this.currentConfig = containerConfig;
+    }
+}

package/src/electron-node/devcontainer-contributions/main-container-creation-contributions.ts

@@ -0,0 +1,196 @@
+// *****************************************************************************
+// Copyright (C) 2024 Typefox 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 Docker from 'dockerode';
+import { inject, injectable, interfaces } from '@theia/core/shared/inversify';
+import { ContainerCreationContribution } from '../docker-container-service';
+import { DevContainerConfiguration, DockerfileContainer, ImageContainer, NonComposeContainerBase } from '../devcontainer-file';
+import { Path } from '@theia/core';
+import { ContainerOutputProvider } from '../../electron-common/container-output-provider';
+import * as fs from '@theia/core/shared/fs-extra';
+import { RemotePortForwardingProvider } from '@theia/remote/lib/electron-common/remote-port-forwarding-provider';
+import { RemoteDockerContainerConnection } from '../remote-container-connection-provider';
+
+export function registerContainerCreationContributions(bind: interfaces.Bind): void {
+    bind(ContainerCreationContribution).to(ImageFileContribution).inSingletonScope();
+    bind(ContainerCreationContribution).to(DockerFileContribution).inSingletonScope();
+    bind(ContainerCreationContribution).to(ForwardPortsContribution).inSingletonScope();
+    bind(ContainerCreationContribution).to(MountsContribution).inSingletonScope();
+    bind(ContainerCreationContribution).to(RemoteUserContribution).inSingletonScope();
+    bind(ContainerCreationContribution).to(PostCreateCommandContribution).inSingletonScope();
+}
+
+@injectable()
+export class ImageFileContribution implements ContainerCreationContribution {
+    async handleContainerCreation(createOptions: Docker.ContainerCreateOptions, containerConfig: ImageContainer,
+        api: Docker, outputprovider: ContainerOutputProvider): Promise<void> {
+        if (containerConfig.image) {
+            const platform = process.platform;
+            const arch = process.arch;
+            const options = platform === 'darwin' && arch === 'arm64' ? { platform: 'amd64' } : {};
+            await new Promise<void>((res, rej) => api.pull(containerConfig.image, options, (err, stream) => {
+                if (err) {
+                    rej(err);
+                } else if (stream === undefined) {
+                    rej('Stream is undefined');
+                } else {
+                    api.modem.followProgress(stream, (error, output) => error ?
+                        rej(error) :
+                        res(), progress => outputprovider.onRemoteOutput(OutputHelper.parseProgress(progress)));
+                }
+            }));
+            createOptions.Image = containerConfig.image;
+        }
+    }
+}
+
+@injectable()
+export class DockerFileContribution implements ContainerCreationContribution {
+    async handleContainerCreation(createOptions: Docker.ContainerCreateOptions, containerConfig: DockerfileContainer,
+        api: Docker, outputprovider: ContainerOutputProvider): Promise<void> {
+        // check if dockerfile container
+        if (containerConfig.dockerFile || containerConfig.build?.dockerfile) {
+            const dockerfile = (containerConfig.dockerFile ?? containerConfig.build?.dockerfile) as string;
+            const context = containerConfig.context ?? new Path(containerConfig.location as string).dir.fsPath();
+            try {
+                // ensure dockerfile exists
+                await fs.lstat(new Path(context as string).join(dockerfile).fsPath());
+
+                const buildStream = await api.buildImage({
+                    context,
+                    src: [dockerfile],
+                } as Docker.ImageBuildContext, {
+                    buildargs: containerConfig.build?.args
+                });
+                // TODO probably have some console windows showing the output of the build
+                const imageId = await new Promise<string>((res, rej) => api.modem.followProgress(buildStream!, (err, outputs) => {
+                    if (err) {
+                        rej(err);
+                    } else {
+                        for (let i = outputs.length - 1; i >= 0; i--) {
+                            if (outputs[i].aux?.ID) {
+                                res(outputs[i].aux.ID);
+                                return;
+                            }
+                        }
+                    }
+                }, progress => outputprovider.onRemoteOutput(OutputHelper.parseProgress(progress))));
+                createOptions.Image = imageId;
+            } catch (error) {
+                outputprovider.onRemoteOutput(`could not build dockerfile "${dockerfile}" reason: ${error.message}`);
+                throw error;
+            }
+        }
+    }
+}
+
+@injectable()
+export class ForwardPortsContribution implements ContainerCreationContribution {
+
+    @inject(RemotePortForwardingProvider)
+    protected readonly portForwardingProvider: RemotePortForwardingProvider;
+
+    async handlePostConnect(containerConfig: DevContainerConfiguration, connection: RemoteDockerContainerConnection): Promise<void> {
+        if (!containerConfig.forwardPorts) {
+            return;
+        }
+
+        for (const forward of containerConfig.forwardPorts) {
+            let port: number;
+            let address: string | undefined;
+            if (typeof forward === 'string') {
+                const parts = forward.split(':');
+                address = parts[0];
+                port = parseInt(parts[1]);
+            } else {
+                port = forward;
+            }
+
+            this.portForwardingProvider.forwardPort(connection.localPort, { port, address });
+        }
+
+    }
+
+}
+
+@injectable()
+export class MountsContribution implements ContainerCreationContribution {
+    async handleContainerCreation(createOptions: Docker.ContainerCreateOptions, containerConfig: DevContainerConfiguration, api: Docker): Promise<void> {
+        if (!containerConfig.mounts) {
+            return;
+        }
+
+        createOptions.HostConfig!.Mounts!.push(...(containerConfig as NonComposeContainerBase)?.mounts
+            ?.map(mount => typeof mount === 'string' ?
+                this.parseMountString(mount) :
+                { Source: mount.source, Target: mount.target, Type: mount.type ?? 'bind' }) ?? []);
+    }
+
+    parseMountString(mount: string): Docker.MountSettings {
+        const parts = mount.split(',');
+        return {
+            Source: parts.find(part => part.startsWith('source=') || part.startsWith('src='))?.split('=')[1]!,
+            Target: parts.find(part => part.startsWith('target=') || part.startsWith('dst='))?.split('=')[1]!,
+            Type: (parts.find(part => part.startsWith('type='))?.split('=')[1] ?? 'bind') as Docker.MountType
+        };
+    }
+}
+
+@injectable()
+export class RemoteUserContribution implements ContainerCreationContribution {
+    async handleContainerCreation(createOptions: Docker.ContainerCreateOptions, containerConfig: DevContainerConfiguration, api: Docker): Promise<void> {
+        if (containerConfig.remoteUser) {
+            createOptions.User = containerConfig.remoteUser;
+        }
+    }
+}
+
+@injectable()
+export class PostCreateCommandContribution implements ContainerCreationContribution {
+    async handlePostCreate?(containerConfig: DevContainerConfiguration, container: Docker.Container, api: Docker, outputprovider: ContainerOutputProvider): Promise<void> {
+        if (containerConfig.postCreateCommand) {
+            const commands = typeof containerConfig.postCreateCommand === 'object' && !(containerConfig.postCreateCommand instanceof Array) ?
+                Object.values(containerConfig.postCreateCommand) : [containerConfig.postCreateCommand];
+            for (const command of commands) {
+                try {
+                    let exec;
+                    if (command instanceof Array) {
+                        exec = await container.exec({ Cmd: command, AttachStderr: true, AttachStdout: true });
+
+                    } else {
+                        exec = await container.exec({ Cmd: ['sh', '-c', command], AttachStderr: true, AttachStdout: true });
+                    }
+                    const stream = await exec.start({ Tty: true });
+                    stream.on('data', chunk => outputprovider.onRemoteOutput(chunk.toString()));
+                } catch (error) {
+                    outputprovider.onRemoteOutput('could not execute postCreateCommand ' + JSON.stringify(command) + ' reason:' + error.message);
+                }
+            }
+        }
+    }
+}
+
+export namespace OutputHelper {
+    export interface Progress {
+        id?: string;
+        stream: string;
+        status?: string;
+        progress?: string;
+    }
+
+    export function parseProgress(progress: Progress): string {
+        return progress.stream ?? progress.progress ?? progress.status ?? '';
+    }
+}

package/src/electron-node/devcontainer-contributions/profile-file-modification-contribution.ts

@@ -0,0 +1,35 @@
+// *****************************************************************************
+// Copyright (C) 2024 Typefox 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 { DevContainerConfiguration } from '../devcontainer-file';
+import { ContainerCreationContribution } from '../docker-container-service';
+import * as Docker from 'dockerode';
+import { injectable } from '@theia/core/shared/inversify';
+import { ContainerOutputProvider } from '../../electron-common/container-output-provider';
+
+/**
+ * this contribution changes the /etc/profile file so that it won't overwrite the PATH variable set by docker
+ */
+@injectable()
+export class ProfileFileModificationContribution implements ContainerCreationContribution {
+    async handlePostCreate(containerConfig: DevContainerConfiguration, container: Docker.Container, api: Docker, outputprovider: ContainerOutputProvider): Promise<void> {
+        const stream = await (await container.exec({
+            Cmd: ['sh', '-c', 'sed -i \'s|PATH="\\([^"]*\\)"|PATH=${PATH:-"\\1"}|g\' /etc/profile'], User: 'root',
+            AttachStderr: true, AttachStdout: true
+        })).start({});
+        stream.on('data', data => outputprovider.onRemoteOutput(data.toString()));
+    }
+}