@codingame/monaco-vscode-workbench-service-override 37.2.0 → 37.3.1

package/vscode/src/vs/sessions/contrib/workspace/browser/workspace.contribution.d.ts

@@ -0,0 +1 @@
+export {};

package/vscode/src/vs/sessions/contrib/workspace/browser/workspace.contribution.js

@@ -0,0 +1,5 @@
+
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { WorkspaceFolderManagementContribution } from './workspaceFolderManagement.js';
+
+registerWorkbenchContribution2(WorkspaceFolderManagementContribution.ID, WorkspaceFolderManagementContribution, WorkbenchPhase.AfterRestored);

package/vscode/src/vs/sessions/contrib/workspace/browser/workspaceFolderManagement.d.ts

@@ -0,0 +1,28 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { ISessionsService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IWorkspaceEditingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/workspaces/common/workspaceEditing.service";
+import { IWorkspaceTrustManagementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service";
+import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { IWorkspaceFolderLabelService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/workspaces/common/workspaceFolderLabelService.service";
+export declare class WorkspaceFolderManagementContribution extends Disposable implements IWorkbenchContribution {
+    private readonly sessionsService;
+    private readonly uriIdentityService;
+    private readonly workspaceContextService;
+    private readonly workspaceEditingService;
+    private readonly workspaceTrustManagementService;
+    private readonly workspaceFolderLabelService;
+    static readonly ID = "workbench.contrib.workspaceFolderManagement";
+    private queue;
+    constructor(sessionsService: ISessionsService, uriIdentityService: IUriIdentityService, workspaceContextService: IWorkspaceContextService, workspaceEditingService: IWorkspaceEditingService, workspaceTrustManagementService: IWorkspaceTrustManagementService, workspaceFolderLabelService: IWorkspaceFolderLabelService);
+    private updateWorkspaceFoldersForSession;
+    private getActiveSessionFolderData;
+    /**
+     * Whether `uri` may be mounted as the workspace folder. A session that
+     * requires workspace trust may only mount a trusted folder; anything else is
+     * left unmounted so the window never enters Restricted Mode behind the user's
+     * back. Sessions that don't require trust (e.g. virtual/cloud) always mount.
+     */
+    private isFolderMountable;
+}

package/vscode/src/vs/sessions/contrib/workspace/browser/workspaceFolderManagement.js

@@ -0,0 +1,95 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { ensureSessionWorktreesTrusted } from '../../../services/sessions/browser/worktreeTrust.js';
+import { WorkspaceFolder } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { IWorkspaceEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/workspaces/common/workspaceEditing.service';
+import { IWorkspaceTrustManagementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service';
+import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { Queue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { IWorkspaceFolderLabelService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/workspaces/common/workspaceFolderLabelService.service';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+let WorkspaceFolderManagementContribution = class WorkspaceFolderManagementContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.workspaceFolderManagement";
+    }
+    constructor(
+        sessionsService,
+        uriIdentityService,
+        workspaceContextService,
+        workspaceEditingService,
+        workspaceTrustManagementService,
+        workspaceFolderLabelService
+    ) {
+        super();
+        this.sessionsService = sessionsService;
+        this.uriIdentityService = uriIdentityService;
+        this.workspaceContextService = workspaceContextService;
+        this.workspaceEditingService = workspaceEditingService;
+        this.workspaceTrustManagementService = workspaceTrustManagementService;
+        this.workspaceFolderLabelService = workspaceFolderLabelService;
+        this.queue = this._register(( new Queue()));
+        this._register(autorun(reader => {
+            const activeSession = this.sessionsService.activeSession.read(reader);
+            activeSession?.workspace.read(reader);
+            this.queue.queue(() => this.updateWorkspaceFoldersForSession(activeSession));
+        }));
+    }
+    async updateWorkspaceFoldersForSession(session) {
+        await ensureSessionWorktreesTrusted(session?.workspace.get(), this.workspaceTrustManagementService);
+        const activeSessionFolderData = this.getActiveSessionFolderData(session);
+        const currentRepo = this.workspaceContextService.getWorkspace().folders[0]?.uri;
+        if (activeSessionFolderData && !(await this.isFolderMountable(session, activeSessionFolderData.uri))) {
+            if (currentRepo) {
+                await this.workspaceEditingService.removeFolders([currentRepo], true);
+            }
+            return;
+        }
+        if (!activeSessionFolderData) {
+            if (currentRepo) {
+                await this.workspaceEditingService.removeFolders([currentRepo], true);
+            }
+            return;
+        }
+        if (!currentRepo) {
+            await this.workspaceEditingService.addFolders([activeSessionFolderData], true);
+            return;
+        }
+        if (this.uriIdentityService.extUri.isEqual(currentRepo, activeSessionFolderData.uri)) {
+            return;
+        }
+        await this.workspaceEditingService.updateFolders(0, 1, [activeSessionFolderData], true);
+    }
+    getActiveSessionFolderData(session) {
+        if (!session) {
+            return undefined;
+        }
+        const workspace = session.workspace.get();
+        const folder = workspace?.folders[0];
+        if (!folder) {
+            return undefined;
+        }
+        return {
+            uri: folder.workingDirectory,
+            name: this.workspaceFolderLabelService.getWorkspaceFolderLabel(( new WorkspaceFolder({
+                uri: folder.workingDirectory,
+                name: workspace.label,
+                index: 0
+            })), true) ?? workspace.label
+        };
+    }
+    async isFolderMountable(session, uri) {
+        const workspace = session?.workspace.get();
+        if (!workspace?.requiresWorkspaceTrust) {
+            return true;
+        }
+        return (await this.workspaceTrustManagementService.getUriTrustInfo(uri)).trusted;
+    }
+};
+WorkspaceFolderManagementContribution = ( __decorate([( __param(0, ISessionsService)), ( __param(1, IUriIdentityService)), ( __param(2, IWorkspaceContextService)), ( __param(3, IWorkspaceEditingService)), ( __param(4, IWorkspaceTrustManagementService)), ( __param(5, IWorkspaceFolderLabelService))], WorkspaceFolderManagementContribution));
+
+export { WorkspaceFolderManagementContribution };

package/vscode/src/vs/sessions/services/agentHostFilter/browser/agentHostFilterService.d.ts

@@ -0,0 +1,79 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IRemoteAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IAgentHostGroup } from "@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+import { IAgentHostFilterEntry } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/agentHostFilter/common/agentHostFilter";
+import { IAgentHostFilterService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/agentHostFilter/common/agentHostFilter.service";
+export declare class AgentHostFilterService extends Disposable implements IAgentHostFilterService {
+    private readonly _sessionsProvidersService;
+    private readonly _remoteAgentHostService;
+    private readonly _storageService;
+    readonly _serviceBrand: undefined;
+    private readonly _onDidChange;
+    readonly onDidChange: Event<void>;
+    private readonly _onDidChangeDiscovering;
+    readonly onDidChangeDiscovering: Event<void>;
+    private _selectedHostId;
+    /**
+     * `true` while {@link _selectedHostId} comes from the fallback rather than
+     * from the user. An automatic choice is provisional and can be replaced.
+     */
+    private _selectionIsAutomatic;
+    private _hosts;
+    /**
+     * Discovery handlers contributed by host providers (e.g. dev tunnels).
+     * {@link rediscover} fans out to every handler and waits for them to
+     * settle.
+     */
+    private readonly _discoveryHandlers;
+    /**
+     * Number of in-flight {@link rediscover} calls. {@link isDiscovering}
+     * is `true` while this is non-zero. Tracked as a counter so concurrent
+     * calls don't race a flag back to `false`.
+     */
+    private _discoveringCount;
+    /**
+     * Groups declared via {@link registerHostGroup}. Each always yields an
+     * entry, whether or not any member provider exists yet.
+     */
+    private readonly _declaredGroups;
+    /**
+     * Subscriptions to the `connectionStatus` observable of every currently
+     * registered remote provider. Rebuilt whenever the set of providers
+     * changes so we always observe the live set.
+     */
+    private readonly _providerWatchers;
+    constructor(_sessionsProvidersService: ISessionsProvidersService, _remoteAgentHostService: IRemoteAgentHostService, _storageService: IStorageService);
+    get selectedHostId(): string | undefined;
+    get selectedHost(): IAgentHostFilterEntry | undefined;
+    get hosts(): readonly IAgentHostFilterEntry[];
+    get isDiscovering(): boolean;
+    rediscover(): Promise<void>;
+    registerDiscoveryHandler(handler: () => Promise<void>): IDisposable;
+    registerHostGroup(group: IAgentHostGroup): IDisposable;
+    setSelectedHostId(hostId: string): void;
+    reconnect(hostId: string): void;
+    disconnect(hostId: string): void;
+    /**
+     * Resolve a selection against the live entry list. A selection made by the
+     * fallback is provisional and is replaced once a connectable entry shows
+     * up; an explicit user choice is always kept.
+     */
+    private _validate;
+    /**
+     * Subscribe to the current set of remote providers so that host list
+     * updates (registration/unregistration and status changes) are surfaced
+     * via {@link onDidChange}. One `autorun` reads every provider's
+     * `connectionStatus` observable and recomputes the entry list, folding
+     * providers that declare an {@link IAgentHostGroup} into a single entry.
+     */
+    private _rewatchProviders;
+    private _applyHosts;
+    /**
+     * Store an explicit user choice. Automatic selections are deliberately not
+     * stored, so a restart re-runs the fallback against the hosts of the day.
+     */
+    private _persist;
+}

package/vscode/src/vs/sessions/services/agentHostFilter/browser/agentHostFilterService.js

@@ -0,0 +1,259 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isWeb } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { IRemoteAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { isAgentHostProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { AgentHostFilterConnectionStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/agentHostFilter/common/agentHostFilter';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+const STORAGE_KEY = "sessions.agentHostFilter.selectedProviderId";
+function mapStatus(s) {
+    switch (s.kind) {
+    case "connected":
+        return AgentHostFilterConnectionStatus.Connected;
+    case "connecting":
+        return AgentHostFilterConnectionStatus.Connecting;
+    case "reconnecting":
+        return AgentHostFilterConnectionStatus.Connecting;
+    case "disconnected":
+    case "incompatible":
+    default:
+        return AgentHostFilterConnectionStatus.Disconnected;
+    }
+}
+function rollupStatus(statuses) {
+    if (statuses.includes(AgentHostFilterConnectionStatus.Connected)) {
+        return AgentHostFilterConnectionStatus.Connected;
+    }
+    if (statuses.includes(AgentHostFilterConnectionStatus.Connecting)) {
+        return AgentHostFilterConnectionStatus.Connecting;
+    }
+    return AgentHostFilterConnectionStatus.Disconnected;
+}
+function isRemoteAgentHostProvider(provider) {
+    if (!provider || typeof provider !== "object" || !("id" in provider)) {
+        return false;
+    }
+    const p = provider;
+    return isAgentHostProvider(p) && p.connectionStatus !== undefined && typeof p.remoteAddress === "string";
+}
+let AgentHostFilterService = class AgentHostFilterService extends Disposable {
+    constructor(_sessionsProvidersService, _remoteAgentHostService, _storageService) {
+        super();
+        this._sessionsProvidersService = _sessionsProvidersService;
+        this._remoteAgentHostService = _remoteAgentHostService;
+        this._storageService = _storageService;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._onDidChangeDiscovering = this._register(( new Emitter()));
+        this.onDidChangeDiscovering = this._onDidChangeDiscovering.event;
+        this._selectionIsAutomatic = false;
+        this._hosts = [];
+        this._discoveryHandlers = ( new Set());
+        this._discoveringCount = 0;
+        this._declaredGroups = ( new Map());
+        this._providerWatchers = this._register(( new DisposableStore()));
+        this._selectedHostId = this._storageService.get(STORAGE_KEY, StorageScope.PROFILE, undefined);
+        this._rewatchProviders();
+        this._register(
+            this._sessionsProvidersService.onDidChangeProviders(() => this._rewatchProviders())
+        );
+    }
+    get selectedHostId() {
+        return this._selectedHostId;
+    }
+    get selectedHost() {
+        if (this._selectedHostId === undefined) {
+            return undefined;
+        }
+        return this._hosts.find(h => h.id === this._selectedHostId);
+    }
+    get hosts() {
+        return this._hosts;
+    }
+    get isDiscovering() {
+        return this._discoveringCount > 0;
+    }
+    async rediscover() {
+        if (this._discoveryHandlers.size === 0) {
+            return;
+        }
+        this._discoveringCount++;
+        if (this._discoveringCount === 1) {
+            this._onDidChangeDiscovering.fire();
+        }
+        try {
+            await Promise.allSettled([...this._discoveryHandlers].map(h => h().catch(() => {})));
+        } finally {
+            this._discoveringCount--;
+            if (this._discoveringCount === 0) {
+                this._onDidChangeDiscovering.fire();
+            }
+        }
+    }
+    registerDiscoveryHandler(handler) {
+        this._discoveryHandlers.add(handler);
+        return toDisposable(() => this._discoveryHandlers.delete(handler));
+    }
+    registerHostGroup(group) {
+        this._declaredGroups.set(group.id, group);
+        this._rewatchProviders();
+        return toDisposable(() => {
+            if (this._declaredGroups.delete(group.id) && !this._providerWatchers.isDisposed) {
+                this._rewatchProviders();
+            }
+        });
+    }
+    setSelectedHostId(hostId) {
+        if (!( this._hosts.some(h => h.id === hostId))) {
+            return;
+        }
+        const changed = hostId !== this._selectedHostId;
+        this._selectedHostId = hostId;
+        this._selectionIsAutomatic = false;
+        this._persist(hostId);
+        if (changed) {
+            this._onDidChange.fire();
+        }
+    }
+    reconnect(hostId) {
+        const host = this._hosts.find(h => h.id === hostId);
+        if (!host) {
+            return;
+        }
+        for (const providerId of host.providerIds) {
+            const provider = this._sessionsProvidersService.getProvider(providerId);
+            if (provider && isAgentHostProvider(provider) && provider.connect) {
+                provider.connect().catch(() => {});
+                continue;
+            }
+            const address = provider && isAgentHostProvider(provider) ? provider.remoteAddress : host.address;
+            if (address) {
+                this._remoteAgentHostService.reconnect(address);
+            }
+        }
+    }
+    disconnect(hostId) {
+        const host = this._hosts.find(h => h.id === hostId);
+        if (!host) {
+            return;
+        }
+        for (const providerId of host.providerIds) {
+            const provider = this._sessionsProvidersService.getProvider(providerId);
+            if (provider && isAgentHostProvider(provider) && provider.disconnect) {
+                provider.disconnect().catch(() => {});
+            }
+        }
+    }
+    _validate(hostId) {
+        if (this._hosts.length === 0) {
+            return {
+                id: undefined,
+                automatic: false
+            };
+        }
+        const current = hostId === undefined ? undefined : this._hosts.find(h => h.id === hostId);
+        if (current && (!this._selectionIsAutomatic || current.connectable)) {
+            return {
+                id: current.id,
+                automatic: this._selectionIsAutomatic
+            };
+        }
+        const connectable = this._hosts.find(h => h.connectable);
+        return {
+            id: (connectable ?? current ?? this._hosts[0]).id,
+            automatic: true
+        };
+    }
+    _rewatchProviders() {
+        this._providerWatchers.clear();
+        const providers = this._sessionsProvidersService.getProviders().filter(isRemoteAgentHostProvider);
+        this._providerWatchers.add(autorun(reader => {
+            const grouped = ( new Map());
+            const entries = [];
+            const groupEntry = group => {
+                let entry = grouped.get(group.id);
+                if (!entry) {
+                    entry = {
+                        id: group.id,
+                        providerIds: [],
+                        label: group.label,
+                        grouped: true,
+                        address: undefined,
+                        icon: group.icon ?? Codicon.remote,
+                        status: AgentHostFilterConnectionStatus.Disconnected,
+                        connectable: group.connectable !== false,
+                        order: group.order ?? 0
+                    };
+                    grouped.set(group.id, entry);
+                    entries.push(entry);
+                }
+                return entry;
+            };
+            for (const group of ( this._declaredGroups.values())) {
+                groupEntry(group);
+            }
+            for (const provider of providers) {
+                const status = mapStatus(provider.connectionStatus.read(reader));
+                const group = provider.hostGroup;
+                if (!group) {
+                    entries.push({
+                        id: provider.id,
+                        providerIds: [provider.id],
+                        label: provider.label,
+                        grouped: false,
+                        address: provider.remoteAddress,
+                        icon: provider.icon,
+                        status,
+                        connectable: true,
+                        order: 0
+                    });
+                    continue;
+                }
+                const entry = groupEntry(group);
+                entry.providerIds.push(provider.id);
+                entry.status = rollupStatus([entry.status, status]);
+            }
+            entries.sort((a, b) => a.order - b.order || a.label.localeCompare(b.label));
+            this._applyHosts(entries.map((
+                {
+                    order,
+                    ...entry
+                }
+            ) => entry));
+        }));
+    }
+    _applyHosts(hosts) {
+        const changed = hosts.length !== this._hosts.length || ( hosts.some(
+            (h, i) => h.id !== this._hosts[i].id || h.label !== this._hosts[i].label || h.address !== this._hosts[i].address || h.status !== this._hosts[i].status || h.providerIds.length !== this._hosts[i].providerIds.length || ( h.providerIds.some((p, j) => p !== this._hosts[i].providerIds[j]))
+        ));
+        this._hosts = hosts;
+        const validated = isWeb ? this._validate(this._selectedHostId) : {
+            id: undefined,
+            automatic: false
+        };
+        const selectionChanged = validated.id !== this._selectedHostId;
+        if (selectionChanged) {
+            this._selectedHostId = validated.id;
+        }
+        this._selectionIsAutomatic = validated.automatic;
+        if (changed || selectionChanged) {
+            this._onDidChange.fire();
+        }
+    }
+    _persist(hostId) {
+        this._storageService.store(STORAGE_KEY, hostId, StorageScope.PROFILE, StorageTarget.USER);
+    }
+};
+AgentHostFilterService = ( __decorate([( __param(0, ISessionsProvidersService)), ( __param(1, IRemoteAgentHostService)), ( __param(2, IStorageService))], AgentHostFilterService));
+
+export { AgentHostFilterService };

package/vscode/src/vs/sessions/services/customView/browser/customView.d.ts

@@ -0,0 +1,42 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { MenuId } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { SyncDescriptor } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors";
+/**
+ * How a custom view renders the actions in its header: as an icon toolbar or as
+ * a row of labelled buttons. Both render the same menu, so contributed actions
+ * and their `when` clauses are identical either way.
+ */
+export type CustomViewActionsStyle = "toolbar" | "buttonBar";
+export interface ICustomViewActions {
+    readonly style: CustomViewActionsStyle;
+    readonly menuId: MenuId;
+}
+export interface ICustomViewDescriptor {
+    /** Stable id, used by `ICustomViewService.showCustomView`. */
+    readonly id: string;
+    readonly ctor: SyncDescriptor<AbstractCustomView>;
+    readonly actions?: ICustomViewActions;
+}
+/**
+ * A full-surface view hosted in the custom view grid, in place of the sessions
+ * grid. The host renders the surrounding chrome (header with title, description
+ * and actions, plus the scroll container); a view only fills its content area
+ * and is disposed when it is hidden.
+ */
+export declare abstract class AbstractCustomView extends Disposable {
+    /** Shown in the header. Observable so it can settle after an async load. */
+    abstract readonly title: IObservable<string>;
+    /** Optional secondary line below the title. */
+    readonly description: IObservable<string | undefined>;
+    /**
+     * Width the content is capped to. Defaults to the same measure the session
+     * views use.
+     */
+    readonly maxWidth: number | undefined;
+    /** Renders the content into the host-provided container. Called once. */
+    abstract render(container: HTMLElement): void;
+    /** Called whenever the available content area changes. */
+    abstract layout(width: number, height: number): void;
+    focus(): void;
+}

package/vscode/src/vs/sessions/services/customView/browser/customView.js

@@ -0,0 +1,15 @@
+
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { constObservable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/constObservable';
+
+class AbstractCustomView extends Disposable {
+    constructor() {
+        super(...arguments);
+        this.description = constObservable(undefined);
+        this.maxWidth = undefined;
+    }
+    focus() { }
+}
+
+export { AbstractCustomView };

package/vscode/src/vs/sessions/services/customView/browser/customViewService.d.ts

@@ -0,0 +1,21 @@
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { ICustomViewDescriptor } from "./customView.js";
+import { ICustomViewService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/customView/browser/customViewService.service";
+export declare class CustomViewService extends Disposable implements ICustomViewService {
+    private readonly _logService;
+    private readonly _storageService;
+    readonly _serviceBrand: undefined;
+    private readonly _descriptors;
+    private _desiredCustomViewId;
+    private readonly _activeCustomView;
+    readonly activeCustomView: IObservable<ICustomViewDescriptor | undefined>;
+    constructor(_logService: ILogService, _storageService: IStorageService);
+    registerCustomView(descriptor: ICustomViewDescriptor, options?: {
+        readonly restore?: boolean;
+    }): IDisposable;
+    showCustomView(id: string): void;
+    hideCustomView(): void;
+}

package/vscode/src/vs/sessions/services/customView/browser/customViewService.js

@@ -0,0 +1,68 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+
+const ACTIVE_CUSTOM_VIEW_STORAGE_KEY = "sessions.activeCustomView";
+let CustomViewService = class CustomViewService extends Disposable {
+    constructor(_logService, _storageService) {
+        super();
+        this._logService = _logService;
+        this._storageService = _storageService;
+        this._descriptors = ( new Map());
+        this._activeCustomView = observableValue(this, undefined);
+        this.activeCustomView = this._activeCustomView;
+        this._desiredCustomViewId = this._storageService.get(ACTIVE_CUSTOM_VIEW_STORAGE_KEY, StorageScope.WORKSPACE);
+    }
+    registerCustomView(descriptor, options) {
+        if (( this._descriptors.has(descriptor.id))) {
+            throw ( new Error(`A custom view with id '${descriptor.id}' is already registered`));
+        }
+        this._descriptors.set(descriptor.id, descriptor);
+        if (this._desiredCustomViewId === descriptor.id) {
+            if (options?.restore === false) {
+                this._desiredCustomViewId = undefined;
+                this._storageService.remove(ACTIVE_CUSTOM_VIEW_STORAGE_KEY, StorageScope.WORKSPACE);
+            } else {
+                this._activeCustomView.set(descriptor, undefined);
+            }
+        }
+        return toDisposable(() => {
+            this._descriptors.delete(descriptor.id);
+            if (this._activeCustomView.get() === descriptor) {
+                this._activeCustomView.set(undefined, undefined);
+            }
+        });
+    }
+    showCustomView(id) {
+        const descriptor = this._descriptors.get(id);
+        if (!descriptor) {
+            this._logService.warn(
+                `[CustomViewService] showCustomView: no custom view registered with id '${id}'`
+            );
+            return;
+        }
+        this._desiredCustomViewId = id;
+        this._storageService.store(
+            ACTIVE_CUSTOM_VIEW_STORAGE_KEY,
+            id,
+            StorageScope.WORKSPACE,
+            StorageTarget.MACHINE
+        );
+        this._activeCustomView.set(descriptor, undefined);
+    }
+    hideCustomView() {
+        this._desiredCustomViewId = undefined;
+        this._storageService.remove(ACTIVE_CUSTOM_VIEW_STORAGE_KEY, StorageScope.WORKSPACE);
+        this._activeCustomView.set(undefined, undefined);
+    }
+};
+CustomViewService = ( __decorate([( __param(0, ILogService)), ( __param(1, IStorageService))], CustomViewService));
+
+export { CustomViewService };