@theia/dev-container 1.72.0-next.59 → 1.72.0

package/src/electron-node/dev-container-cli-contribution.ts

@@ -0,0 +1,68 @@
+// *****************************************************************************
+// 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 { CliContribution } from '@theia/core/lib/node';
+import { injectable } from '@theia/core/shared/inversify';
+import { Arguments, Argv } from '@theia/core/shared/yargs';
+
+/**
+ * Handles the `--attach-container` CLI argument and stashes the value.
+ */
+@injectable()
+export class DevContainerCliContribution implements CliContribution {
+
+    protected attachContainerId: string | undefined;
+
+    protected scanForDevJson: boolean = true;
+
+    configure(conf: Argv): void {
+        conf.option('attach-container', {
+            description: 'Attach to a running Docker container by ID or name on startup',
+            type: 'string'
+        });
+        conf.option('dev-json', {
+            description: 'Scan for and apply devcontainer.json when attaching to a container (use --no-dev-json to skip)',
+            type: 'boolean',
+            default: true
+        });
+    }
+
+    setArguments(args: Arguments): void {
+        if (args['attach-container'] !== undefined) {
+            const id = String(args['attach-container']).trim();
+            this.attachContainerId = id.length > 0 ? id : undefined;
+        }
+        this.scanForDevJson = args['dev-json'] !== false;
+    }
+
+    getAttachContainerId(): string | undefined {
+        return this.attachContainerId;
+    }
+
+    /**
+     * Returns and clears the attach container ID so the startup attach flow
+     * runs at most once (the window reloads after connecting to the remote).
+     */
+    consumeAttachContainerId(): string | undefined {
+        const id = this.attachContainerId;
+        this.attachContainerId = undefined;
+        return id;
+    }
+
+    shouldScanForDevJson(): boolean {
+        return this.scanForDevJson;
+    }
+}

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

@@ -21,7 +21,7 @@ import { DevContainerConfiguration } from './devcontainer-file';
 import { parse } from 'jsonc-parser';
 import * as fs from '@theia/core/shared/fs-extra';
 import { ContributionProvider, Path, URI } from '@theia/core';
-import { VariableResolverContribution } from './devcontainer-contributions/variable-resolver-contribution';
+import { VariableContext, VariableResolverContribution } from './devcontainer-contributions/variable-resolver-contribution';
 
 const VARIABLE_REGEX = /\$\{(.+?)(?::(.+?))?\}/g;
 
@@ -34,39 +34,39 @@ export class DevContainerFileService {
     @inject(ContributionProvider) @named(VariableResolverContribution)
     protected readonly variableResolverContributions: ContributionProvider<VariableResolverContribution>;
 
-    protected resolveVariable(value: string): string {
+    protected resolveVariable(value: string, context?: VariableContext): string {
         return value.replace(VARIABLE_REGEX, (match, type, variable) => {
             for (const contribution of this.variableResolverContributions.getContributions()) {
-                if (contribution.canResolve(type)) {
-                    return contribution.resolve(variable ?? type);
+                if (contribution.canResolve(type, context)) {
+                    return contribution.resolve(variable ?? type, context);
                 }
             }
             return match;
         });
     }
 
-    protected resolveVariablesRecursively<T>(obj: T): T {
+    protected resolveVariablesRecursively<T>(obj: T, context?: VariableContext): T {
         if (typeof obj === 'string') {
-            return this.resolveVariable(obj) as T;
+            return this.resolveVariable(obj, context) as T;
         } else if (Array.isArray(obj)) {
-            return obj.map(item => this.resolveVariablesRecursively(item)) as T;
+            return obj.map(item => this.resolveVariablesRecursively(item, context)) as T;
         } else if (obj && typeof obj === 'object') {
             const newObj: Record<string, unknown> = {};
             for (const [key, value] of Object.entries(obj)) {
-                newObj[key] = this.resolveVariablesRecursively(value);
+                newObj[key] = this.resolveVariablesRecursively(value, context);
             }
             return newObj as T;
         }
         return obj;
     }
 
-    async getConfiguration(path: string): Promise<DevContainerConfiguration> {
+    async getConfiguration(path: string, context?: VariableContext): Promise<DevContainerConfiguration> {
         let 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 = this.resolveVariablesRecursively(configuration);
+        configuration = this.resolveVariablesRecursively(configuration, context);
         configuration.location = path;
         return configuration;
     }

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

@@ -24,7 +24,7 @@ import * as os from 'os';
 import * as path from 'path';
 import * as cp from 'child_process';
 import { ForwardedPort, RemotePortForwardingProvider } from '@theia/remote/lib/electron-common/remote-port-forwarding-provider';
-import { RemoteDockerContainerConnection } from '../remote-container-connection-provider';
+import { RemoteDockerContainerConnection } from '../remote-docker-container-connection';
 import { WorkspaceCreationContribution } from './workspace-creation-contribution';
 import { parseWorkspaceMount } from '../dockerode-utils';
 
@@ -49,6 +49,7 @@ export class ImageFileContribution implements ContainerCreationContribution {
             const platform = process.platform;
             const arch = process.arch;
             const options = platform === 'darwin' && arch === 'arm64' ? { platform: 'amd64' } : {};
+            const dedup = OutputHelper.createDedupContext();
             await new Promise<void>((res, rej) => api.pull(containerConfig.image, options, (err, stream) => {
                 if (err) {
                     rej(err);
@@ -57,7 +58,7 @@ export class ImageFileContribution implements ContainerCreationContribution {
                 } else {
                     api.modem.followProgress(stream!, (error, output) => error ?
                         rej(error) :
-                        res(), progress => outputprovider.onRemoteOutput(OutputHelper.parseProgress(progress)));
+                        res(), progress => outputprovider.onRemoteOutput(OutputHelper.parseProgress(progress, dedup)));
                 }
             }));
             createOptions.Image = containerConfig.image;
@@ -84,6 +85,7 @@ export class DockerFileContribution implements ContainerCreationContribution {
                     buildargs: containerConfig.build?.args
                 });
                 // TODO probably have some console windows showing the output of the build
+                const dedup = OutputHelper.createDedupContext();
                 const imageId = await new Promise<string>((res, rej) => api.modem.followProgress(buildStream!, (err, outputs) => {
                     if (err) {
                         rej(err);
@@ -95,7 +97,7 @@ export class DockerFileContribution implements ContainerCreationContribution {
                             }
                         }
                     }
-                }, progress => outputprovider.onRemoteOutput(OutputHelper.parseProgress(progress))));
+                }, progress => outputprovider.onRemoteOutput(OutputHelper.parseProgress(progress, dedup))));
                 createOptions.Image = imageId;
             } catch (error) {
                 outputprovider.onRemoteOutput(`Could not build dockerfile "${dockerfile}": ${error.message}`);
@@ -517,7 +519,29 @@ export namespace OutputHelper {
         progress?: string;
     }
 
-    export function parseProgress(progress: Progress): string {
-        return progress.stream ?? progress.progress ?? progress.status ?? '';
+    export interface DedupContext {
+        lastMessage: string;
+    }
+
+    export function createDedupContext(): DedupContext {
+        return { lastMessage: '' };
+    }
+
+    export function parseProgress(progress: Progress, dedup?: DedupContext): string {
+        if (progress.stream) {
+            if (dedup) {
+                dedup.lastMessage = '';
+            }
+            return progress.stream;
+        }
+        const message = progress.progress ?? progress.status ?? '';
+        const formatted = progress.id ? `${progress.id}: ${message}` : message;
+        if (dedup && formatted === dedup.lastMessage) {
+            return '';
+        }
+        if (dedup) {
+            dedup.lastMessage = formatted;
+        }
+        return formatted;
     }
 }

package/src/electron-node/devcontainer-contributions/variable-resolver-contribution.ts

@@ -14,13 +14,16 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { inject, injectable, interfaces, LazyServiceIdentifier } from '@theia/core/shared/inversify';
-import { DockerContainerService } from '../docker-container-service';
+import { injectable, interfaces } from '@theia/core/shared/inversify';
+
+export interface VariableContext {
+    containerId?: string;
+}
 
 export const VariableResolverContribution = Symbol('VariableResolverContribution');
 export interface VariableResolverContribution {
-    canResolve(variable: string): boolean;
-    resolve(variable: string): string;
+    canResolve(variable: string, context?: VariableContext): boolean;
+    resolve(variable: string, context?: VariableContext): string;
 }
 
 export function registerVariableResolverContributions(bind: interfaces.Bind): void {
@@ -41,13 +44,10 @@ export class LocalEnvVariableResolver implements VariableResolverContribution {
 
 @injectable()
 export class ContainerIdResolver implements VariableResolverContribution {
-    @inject(new LazyServiceIdentifier(() => DockerContainerService))
-        protected readonly dockerContainerService: DockerContainerService;
-
-    canResolve(type: string): boolean {
-        return type === 'devcontainerId' && !!this.dockerContainerService.container;
+    canResolve(type: string, context?: VariableContext): boolean {
+        return type === 'devcontainerId' && !!context?.containerId;
     }
-    resolve(variable: string): string {
-        return this.dockerContainerService.container?.id || variable;
+    resolve(_variable: string, context?: VariableContext): string {
+        return context?.containerId ?? _variable;
     }
 }

package/src/electron-node/devcontainer-util.spec.ts

@@ -0,0 +1,154 @@
+// *****************************************************************************
+// 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 { expect } from 'chai';
+import { getWorkspaceMounts, inferWorkspacePath, isWorkspaceMount, MountInfo } from './devcontainer-util';
+import type { ContainerInspectInfo } from 'dockerode';
+
+function createContainerInfo(
+    mounts: Array<{ Destination: string; Type?: string }>,
+    workingDir?: string
+): ContainerInspectInfo {
+    return {
+        Mounts: mounts.map(m => ({ ...m, Type: m.Type ?? 'bind' })),
+        Config: { WorkingDir: workingDir ?? '' }
+    } as unknown as ContainerInspectInfo;
+}
+
+describe('inferWorkspacePath', () => {
+
+    it('should return workspace mount destination', () => {
+        const info = createContainerInfo([{ Destination: '/workspaces/project' }]);
+        expect(inferWorkspacePath(info)).to.equal('/workspaces/project');
+    });
+
+    it('should skip .ssh mount', () => {
+        const info = createContainerInfo([
+            { Destination: '/root/.ssh' },
+            { Destination: '/workspaces/project' }
+        ]);
+        expect(inferWorkspacePath(info)).to.equal('/workspaces/project');
+    });
+
+    it('should skip .gitconfig mount', () => {
+        const info = createContainerInfo([
+            { Destination: '/home/user/.gitconfig' },
+            { Destination: '/workspaces/project' }
+        ]);
+        expect(inferWorkspacePath(info)).to.equal('/workspaces/project');
+    });
+
+    it('should skip /tmp/host_gitconfig mount', () => {
+        const info = createContainerInfo([
+            { Destination: '/tmp/host_gitconfig' },
+            { Destination: '/workspaces/project' }
+        ]);
+        expect(inferWorkspacePath(info)).to.equal('/workspaces/project');
+    });
+
+    it('should skip all injected mounts and find workspace', () => {
+        const info = createContainerInfo([
+            { Destination: '/root/.ssh' },
+            { Destination: '/tmp/host_gitconfig' },
+            { Destination: '/workspace' }
+        ]);
+        expect(inferWorkspacePath(info)).to.equal('/workspace');
+    });
+
+    it('should fall back to WorkingDir when no suitable mounts', () => {
+        const info = createContainerInfo([{ Destination: '/root/.ssh' }], '/app');
+        expect(inferWorkspacePath(info)).to.equal('/app');
+    });
+
+    it('should fall back to / when no mounts and no WorkingDir', () => {
+        const info = createContainerInfo([], '');
+        expect(inferWorkspacePath(info)).to.equal('/');
+    });
+
+    it('should fall back to / when mounts is empty', () => {
+        const info = createContainerInfo([]);
+        expect(inferWorkspacePath(info)).to.equal('/');
+    });
+
+    it('should skip non-bind mounts', () => {
+        const info = createContainerInfo([
+            { Destination: '/data', Type: 'volume' },
+            { Destination: '/workspaces/project' }
+        ]);
+        expect(inferWorkspacePath(info)).to.equal('/workspaces/project');
+    });
+});
+
+describe('isWorkspaceMount', () => {
+
+    function mount(destination: string, type: string = 'bind'): MountInfo {
+        return { Destination: destination, Type: type } as MountInfo;
+    }
+
+    it('should accept a normal bind mount', () => {
+        expect(isWorkspaceMount(mount('/workspaces/project'))).to.be.true;
+    });
+
+    it('should reject .ssh mounts', () => {
+        expect(isWorkspaceMount(mount('/root/.ssh'))).to.be.false;
+    });
+
+    it('should reject .gitconfig mounts', () => {
+        expect(isWorkspaceMount(mount('/home/user/.gitconfig'))).to.be.false;
+    });
+
+    it('should reject /tmp/host_gitconfig', () => {
+        expect(isWorkspaceMount(mount('/tmp/host_gitconfig'))).to.be.false;
+    });
+
+    it('should reject volume mounts', () => {
+        expect(isWorkspaceMount(mount('/workspaces/project', 'volume'))).to.be.false;
+    });
+
+    it('should reject tmpfs mounts', () => {
+        expect(isWorkspaceMount(mount('/workspaces/project', 'tmpfs'))).to.be.false;
+    });
+});
+
+describe('getWorkspaceMounts', () => {
+
+    function mount(destination: string, type: string = 'bind'): MountInfo {
+        return { Destination: destination, Type: type } as MountInfo;
+    }
+
+    it('should filter out injected mounts and return workspace mounts', () => {
+        const mounts = [
+            mount('/root/.ssh'),
+            mount('/workspaces/project'),
+            mount('/tmp/host_gitconfig'),
+            mount('/app'),
+        ];
+        const result = getWorkspaceMounts(mounts);
+        expect(result.map(m => m.Destination)).to.deep.equal(['/workspaces/project', '/app']);
+    });
+
+    it('should return empty array when all mounts are injected', () => {
+        const mounts = [
+            mount('/root/.ssh'),
+            mount('/home/user/.gitconfig'),
+        ];
+        expect(getWorkspaceMounts(mounts)).to.deep.equal([]);
+    });
+
+    it('should return empty array for empty input', () => {
+        expect(getWorkspaceMounts([])).to.deep.equal([]);
+    });
+});

package/src/electron-node/devcontainer-util.ts

@@ -0,0 +1,49 @@
+// *****************************************************************************
+// 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 type { ContainerInspectInfo } from 'dockerode';
+
+export type MountInfo = ContainerInspectInfo['Mounts'][number];
+
+/**
+ * Returns true for bind mounts that are not injected by HostConfigSharingContribution
+ * (SSH dir, gitconfig). Shared by {@link inferWorkspacePath} and
+ * {@link getWorkspaceMounts} to keep the filtering logic in one place.
+ */
+export function isWorkspaceMount(mount: MountInfo): boolean {
+    return mount.Type === 'bind'
+        && !!mount.Destination
+        && !mount.Destination.endsWith('/.ssh')
+        && !mount.Destination.endsWith('/.gitconfig')
+        && mount.Destination !== '/tmp/host_gitconfig';
+}
+
+/**
+ * Returns all bind mounts that look like workspace mounts (filtering out
+ * injected SSH/gitconfig mounts).
+ */
+export function getWorkspaceMounts(mounts: MountInfo[]): MountInfo[] {
+    return mounts.filter(isWorkspaceMount);
+}
+
+/**
+ * Infers a workspace path from container inspect info.
+ * Takes the first workspace-relevant bind mount, falls back to WorkingDir, then `/`.
+ */
+export function inferWorkspacePath(containerInfo: ContainerInspectInfo): string {
+    const workspaceMount = containerInfo.Mounts.find(isWorkspaceMount);
+    return (workspaceMount?.Destination ?? containerInfo.Config.WorkingDir) || '/';
+}

package/src/electron-node/docker-container-service.ts

@@ -15,6 +15,7 @@
 // *****************************************************************************
 
 import { ContributionProvider, MaybePromise, URI } from '@theia/core';
+import { VariableContext } from './devcontainer-contributions/variable-resolver-contribution';
 import { inject, injectable, named } from '@theia/core/shared/inversify';
 import { WorkspaceServer } from '@theia/workspace/lib/common';
 import * as fs from '@theia/core/shared/fs-extra';
@@ -23,7 +24,7 @@ import { ContainerConnectionOptions } from '../electron-common/remote-container-
 import { DevContainerConfiguration, NonComposeContainerBase } from './devcontainer-file';
 import { DevContainerFileService } from './dev-container-file-service';
 import { ContainerOutputProvider } from '../electron-common/container-output-provider';
-import { RemoteDockerContainerConnection } from './remote-container-connection-provider';
+import { RemoteDockerContainerConnection } from './remote-docker-container-connection';
 import { DockerComposeService } from './docker-compose/compose-service';
 
 export const ContainerCreationContribution = Symbol('ContainerCreationContributions');
@@ -64,14 +65,12 @@ export class DockerContainerService {
     @inject(DockerComposeService)
     protected readonly dockerComposeService: DockerComposeService;
 
-    container: Docker.Container | undefined;
-
     async getOrCreateContainer(docker: Docker, options: ContainerConnectionOptions, outputProvider?: ContainerOutputProvider): Promise<Docker.Container> {
         let container;
 
         const workspace = new URI(options.workspacePath ?? await this.workspaceServer.getMostRecentlyUsedWorkspace());
 
-        if (options.lastContainerInfo && fs.statSync(options.devcontainerFile).mtimeMs < options.lastContainerInfo.lastUsed) {
+        if (options.lastContainerInfo && fs.pathExistsSync(options.devcontainerFile) && fs.statSync(options.devcontainerFile).mtimeMs < options.lastContainerInfo.lastUsed) {
             try {
                 container = docker.getContainer(options.lastContainerInfo.id);
                 if ((await container.inspect()).State.Running) {
@@ -87,12 +86,12 @@ export class DockerContainerService {
         if (!container) {
             container = await this.buildContainer(docker, options.devcontainerFile, workspace, outputProvider);
         }
-        this.container = container;
         return container;
     }
 
-    async postConnect(devcontainerFile: string, connection: RemoteDockerContainerConnection, outputProvider?: ContainerOutputProvider): Promise<void> {
-        const devcontainerConfig = await this.devContainerFileService.getConfiguration(devcontainerFile);
+    async postConnect(devcontainerFile: string, connection: RemoteDockerContainerConnection, outputProvider?: ContainerOutputProvider,
+        context?: VariableContext): Promise<void> {
+        const devcontainerConfig = await this.devContainerFileService.getConfiguration(devcontainerFile, context);
 
         for (const containerCreateContrib of this.containerCreationContributions.getContributions()) {
             await containerCreateContrib.handlePostConnect?.(devcontainerConfig, connection, outputProvider);