@codingame/monaco-vscode-workbench-service-override 37.6.0 → 38.0.0

package/vscode/src/vs/sessions/browser/parts/sessionHeaderBar.js

@@ -0,0 +1,391 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as chatCompositeBar from './media/chatCompositeBar.css';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { $, addDisposableListener, EventType, DisposableResizeObserver, getWindow, isMouseEvent, addDisposableGenericMouseDownListener, createElement, addStandardDisposableListener } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { StandardMouseEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/mouseEvent';
+import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { SessionStatus, getUntitledSessionTitle, getChatCapabilities } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { MenuWorkbenchToolBar, HiddenItemStrategy } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
+import { IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
+import { LocalSelectionTransfer } from '@codingame/monaco-vscode-api/vscode/vs/platform/dnd/browser/dnd';
+import { DraggedSessionIdentifier, SessionsDataTransfers } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/dnd';
+import { applyDragImage } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/dnd/dnd';
+import { applySessionBarThemeColors } from './sessionBarStyles.js';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { SessionStatusIcon } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/sessionStatusIcon';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { createSessionActionViewItemProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/sessionActionViewItem';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+registerCss(chatCompositeBar, 0);
+let SessionHeaderBar = class SessionHeaderBar extends Disposable {
+    get element() {
+        return this._container;
+    }
+    get visible() {
+        return this._visible;
+    }
+    get height() {
+        this._height = this._visible ? this._container.offsetHeight : 0;
+        return this._height;
+    }
+    constructor(
+        resizeObserverCtor,
+        _themeService,
+        instantiationService,
+        _contextMenuService,
+        _contextKeyService,
+        _sessionsManagementService,
+        configurationService
+    ) {
+        super();
+        this._themeService = _themeService;
+        this._contextMenuService = _contextMenuService;
+        this._contextKeyService = _contextKeyService;
+        this._sessionsManagementService = _sessionsManagementService;
+        this._sessionDisposables = this._register(( new MutableDisposable()));
+        this._editingDisposables = this._register(( new MutableDisposable()));
+        this._actionsTargetChat = false;
+        this._menuActionArgs = [];
+        this._sessionIsCreated = false;
+        this._requestedVisible = true;
+        this._onDidChangeVisibility = this._register(( new Emitter()));
+        this.onDidChangeVisibility = this._onDidChangeVisibility.event;
+        this._onDidChangeHeight = this._register(( new Emitter()));
+        this.onDidChangeHeight = this._onDidChangeHeight.event;
+        this._visible = false;
+        this._height = 0;
+        this._sessionTransfer = LocalSelectionTransfer.getInstance();
+        this._container = $(".chat-composite-bar.session-header-bar");
+        const header = $(".chat-composite-bar-header");
+        this._container.appendChild(header);
+        this._iconEl = $(".chat-composite-bar-session-icon");
+        header.appendChild(this._iconEl);
+        this._statusIcon = this._register(instantiationService.createInstance(SessionStatusIcon, this._iconEl));
+        const main = $(".chat-composite-bar-header-main");
+        header.appendChild(main);
+        const titleRow = $(".chat-composite-bar-title-row");
+        main.appendChild(titleRow);
+        this._titleEl = $(".chat-composite-bar-session-title");
+        titleRow.appendChild(this._titleEl);
+        this._titleTextEl = $("span.chat-composite-bar-session-title-text");
+        this._titleEl.appendChild(this._titleTextEl);
+        this._register(addDisposableListener(this._titleEl, EventType.CLICK, () => {
+            this.startTitleEditing();
+        }));
+        const titleActions = $(".chat-composite-bar-title-actions");
+        titleRow.appendChild(titleActions);
+        this._titleActionsEl = titleActions;
+        const toolbarContainer = $(".chat-composite-bar-toolbar");
+        titleActions.appendChild(toolbarContainer);
+        this._toolbar = this._register(
+            instantiationService.createInstance(MenuWorkbenchToolBar, toolbarContainer, Menus.SessionBarToolbar, {
+                hiddenItemStrategy: HiddenItemStrategy.Ignore,
+                menuOptions: {
+                    args: this._menuActionArgs
+                },
+                highlightToggledItems: true,
+                actionViewItemProvider: createSessionActionViewItemProvider(instantiationService, configurationService)
+            })
+        );
+        const heightObserver = this._register(( new DisposableResizeObserver("SessionHeaderBar.height", entries => {
+            const entry = entries.find(entry => entry.target === this._container);
+            if (!entry || this._store.isDisposed) {
+                return;
+            }
+            const height = this._visible ? Math.round(entry.borderBoxSize[0]?.blockSize ?? this._container.offsetHeight) : 0;
+            if (this._height !== height) {
+                this._height = height;
+                this._onDidChangeHeight.fire();
+            }
+        }, getWindow(this._container), {
+            resizeObserverCtor
+        })));
+        this._register(heightObserver.observe(this._container, {
+            box: "border-box"
+        }));
+        this._applyVisibility(false);
+        this._updateStyles();
+        this._register(this._themeService.onDidColorThemeChange(() => this._updateStyles()));
+        this._registerDragSource();
+        this._registerContextMenu();
+    }
+    _registerContextMenu() {
+        this._register(addDisposableListener(this._container, EventType.CONTEXT_MENU, e => {
+            this._activateChatGroup?.();
+            const session = this._session;
+            if (!session) {
+                return;
+            }
+            let anchor = this._container;
+            if (isMouseEvent(e)) {
+                anchor = ( new StandardMouseEvent(getWindow(this._container), e));
+            }
+            e.preventDefault();
+            e.stopPropagation();
+            this._contextMenuService.showContextMenu({
+                menuId: Menus.SessionHeaderContext,
+                menuActionOptions: {
+                    args: this._menuActionArgs
+                },
+                getAnchor: () => anchor,
+                contextKeyService: this._contextKeyService
+            });
+        }));
+    }
+    _registerDragSource() {
+        this._container.draggable = true;
+        this._register(addDisposableGenericMouseDownListener(this._container, e => {
+            this._activateChatGroup?.();
+            this._lastPointerDownTarget = e.target ?? undefined;
+        }));
+        this._register(addDisposableListener(this._container, EventType.DRAG_START, e => {
+            const session = this._session;
+            if (!session || !e.dataTransfer) {
+                e.preventDefault();
+                return;
+            }
+            const target = this._lastPointerDownTarget;
+            if (target && this._titleActionsEl.contains(target)) {
+                e.preventDefault();
+                return;
+            }
+            if (this._renameInput) {
+                e.preventDefault();
+                return;
+            }
+            this._sessionTransfer.setData([( new DraggedSessionIdentifier(session.sessionId, session.resource))], DraggedSessionIdentifier.prototype);
+            const payload = JSON.stringify({
+                sessionId: session.sessionId,
+                resource: ( session.resource.toString())
+            });
+            e.dataTransfer.setData(SessionsDataTransfers.SESSION, payload);
+            e.dataTransfer.effectAllowed = "move";
+            applyDragImage(e, this._container, session.title.get());
+        }));
+        this._register(addDisposableListener(this._container, EventType.DRAG_END, () => {
+            this._sessionTransfer.clearData(DraggedSessionIdentifier.prototype);
+        }));
+    }
+    setContext(context) {
+        const session = context?.session;
+        const activeChat = context?.chat;
+        const actionsTargetChat = context?.actionsTargetChat ?? false;
+        const activateChatGroup = context?.activateChatGroup;
+        if (this._session === session && this._activeChatObservable === activeChat && this._actionsTargetChat === actionsTargetChat && this._activateChatGroup === activateChatGroup) {
+            return;
+        }
+        this._cancelTitleEditing();
+        this._session = session;
+        this._activeChatObservable = activeChat;
+        this._actionsTargetChat = actionsTargetChat;
+        this._activateChatGroup = activateChatGroup;
+        this._activeChat = undefined;
+        this._menuActionArgs.splice(0, this._menuActionArgs.length, ...(session ? [session] : []));
+        this._toolbar.context = session;
+        this._statusIcon.reset();
+        const store = ( new DisposableStore());
+        this._sessionDisposables.value = store;
+        if (!session || !activeChat) {
+            this._sessionIsCreated = false;
+            this._updateVisibility();
+            return;
+        }
+        store.add(autorun(reader => {
+            this._updateHeader(session, activeChat, reader);
+        }));
+        store.add(autorun(reader => {
+            this._sessionIsCreated = session.isCreated.read(reader);
+            this._updateVisibility();
+        }));
+    }
+    setVisible(visible) {
+        if (this._requestedVisible === visible) {
+            return;
+        }
+        this._requestedVisible = visible;
+        this._updateVisibility();
+    }
+    _updateVisibility() {
+        this._applyVisibility(this._sessionIsCreated && this._requestedVisible);
+    }
+    _updateHeader(session, activeChatObservable, reader) {
+        const activeChat = activeChatObservable.read(reader);
+        const status = session.status.read(reader);
+        const isRead = activeChat ? activeChat.isRead.read(reader) : session.isRead.read(reader);
+        const isArchived = session.isArchived.read(reader);
+        this._statusIcon.setStatus(status, isRead, isArchived);
+        if (!activeChat) {
+            this._activeChat = undefined;
+            this._titleTextEl.textContent = this._getUntitledTitle(reader);
+            this._titleEl.classList.remove("editable");
+            return;
+        }
+        this._menuActionArgs.splice(
+            0,
+            this._menuActionArgs.length,
+            session,
+            ...(this._actionsTargetChat ? [activeChat] : [])
+        );
+        if (this._activeChat?.resource.toString() !== ( activeChat.resource.toString())) {
+            this._cancelTitleEditing();
+            this._activeChat = activeChat;
+        }
+        this._titleTextEl.textContent = activeChat.status.read(reader) === SessionStatus.Untitled ? this._getUntitledTitle(reader) : activeChat.title.read(reader) || this._getUntitledTitle(reader);
+        this._titleEl.classList.toggle("editable", this._isTitleEditable(reader));
+    }
+    _getUntitledTitle(reader) {
+        return getUntitledSessionTitle(this._session?.isQuickChat?.read(reader) ?? false);
+    }
+    _applyVisibility(visible) {
+        const wasVisible = this._visible;
+        this._visible = visible;
+        this._container.style.display = this._visible ? "" : "none";
+        if (wasVisible !== this._visible) {
+            this._onDidChangeVisibility.fire(this._visible);
+        }
+    }
+    _updateStyles() {
+        applySessionBarThemeColors(this._container, this._themeService.getColorTheme());
+    }
+    _isTitleEditable(reader) {
+        return !!this._session && !!this._activeChat && this._activeChat.status.read(reader) !== SessionStatus.Untitled && getChatCapabilities(this._activeChat, this._session, reader).canRename;
+    }
+    startTitleEditing() {
+        if (!this._visible || !this._isTitleEditable()) {
+            return false;
+        }
+        if (this._renameInput) {
+            this._renameInput.focus();
+            this._renameInput.select();
+            return true;
+        }
+        this._startTitleEditing();
+        return true;
+    }
+    _startTitleEditing() {
+        const session = this._session;
+        const activeChat = this._activeChat;
+        if (!session || !activeChat || this._renameInput) {
+            return;
+        }
+        const initialTitle = activeChat.title.get();
+        const fallbackTitle = this._getUntitledTitle();
+        const input = createElement("input");
+        input.type = "text";
+        input.className = "chat-composite-bar-session-title-input";
+        input.value = initialTitle;
+        input.placeholder = fallbackTitle;
+        input.setAttribute("aria-label", ( localize(3436, "Rename chat")));
+        input.spellcheck = false;
+        this._titleTextEl.style.display = "none";
+        this._titleEl.appendChild(input);
+        this._titleEl.classList.add("editing");
+        this._renameInput = input;
+        input.focus();
+        input.select();
+        const store = ( new DisposableStore());
+        this._editingDisposables.value = store;
+        let finished = false;
+        const finish = commit => {
+            if (finished) {
+                return;
+            }
+            finished = true;
+            const newTitle = input.value.trim();
+            this._endTitleEditing();
+            if (commit && newTitle && newTitle !== initialTitle) {
+                this._sessionsManagementService.renameChat(session, activeChat.resource, newTitle).catch(onUnexpectedError);
+            }
+        };
+        store.add(addStandardDisposableListener(input, EventType.KEY_DOWN, e => {
+            if (e.equals(KeyCode.Enter)) {
+                e.preventDefault();
+                e.stopPropagation();
+                finish(true);
+            } else if (e.equals(KeyCode.Escape)) {
+                e.preventDefault();
+                e.stopPropagation();
+                finish(false);
+            } else {
+                e.stopPropagation();
+            }
+        }));
+        store.add(addDisposableListener(input, EventType.BLUR, () => {
+            finish(false);
+        }));
+        store.add(addDisposableGenericMouseDownListener(input, e => e.stopPropagation()));
+        store.add(addDisposableListener(input, EventType.CLICK, e => e.stopPropagation()));
+    }
+    _cancelTitleEditing() {
+        if (!this._renameInput) {
+            return;
+        }
+        this._endTitleEditing();
+    }
+    _endTitleEditing() {
+        if (this._renameInput) {
+            this._renameInput.remove();
+            this._renameInput = undefined;
+        }
+        this._titleTextEl.style.display = "";
+        this._titleEl.classList.remove("editing");
+        this._editingDisposables.clear();
+    }
+};
+SessionHeaderBar = ( __decorate([( __param(1, IThemeService)), ( __param(2, IInstantiationService)), ( __param(3, IContextMenuService)), ( __param(4, IContextKeyService)), ( __param(5, ISessionsManagementService)), ( __param(6, IConfigurationService))], SessionHeaderBar));
+let SessionViewFloatingToolbar = class SessionViewFloatingToolbar extends Disposable {
+    get element() {
+        return this._container;
+    }
+    constructor(instantiationService, configurationService) {
+        super();
+        this._sessionDisposables = this._register(( new MutableDisposable()));
+        this._container = $(".chat-composite-bar.chat-composite-bar-toolbar-floating");
+        const toolbar = $(".chat-composite-bar-toolbar");
+        this._container.appendChild(toolbar);
+        this._toolbar = this._register(
+            instantiationService.createInstance(MenuWorkbenchToolBar, toolbar, Menus.SessionBarToolbar, {
+                hiddenItemStrategy: HiddenItemStrategy.Ignore,
+                menuOptions: {
+                    shouldForwardArgs: true
+                },
+                highlightToggledItems: true,
+                actionViewItemProvider: createSessionActionViewItemProvider(instantiationService, configurationService)
+            })
+        );
+        this._setVisible(false);
+    }
+    setSession(session) {
+        if (this._session === session) {
+            return;
+        }
+        this._session = session;
+        this._toolbar.context = session;
+        const store = ( new DisposableStore());
+        this._sessionDisposables.value = store;
+        if (!session) {
+            this._setVisible(false);
+            return;
+        }
+        store.add(autorun(reader => {
+            this._setVisible(!session.isCreated.read(reader));
+        }));
+    }
+    _setVisible(visible) {
+        this._container.style.display = visible ? "" : "none";
+    }
+};
+SessionViewFloatingToolbar = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IConfigurationService))], SessionViewFloatingToolbar));
+
+export { SessionHeaderBar, SessionViewFloatingToolbar };

package/vscode/src/vs/sessions/browser/parts/sessionReadOnlyBanner.d.ts

@@ -1,5 +1,6 @@
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 /**
  * Content shown by a {@link SessionReadOnlyBanner}: an optional icon, message,
  * and optional inline action. The action's callback is supplied by the owner so
@@ -16,8 +17,9 @@ export interface ISessionReadOnlyBannerContent {
     readonly ariaLabel?: string;
     readonly action?: {
         readonly label: string;
-        readonly run: () => void;
+        readonly run: () => void | Promise<void>;
     };
+    readonly secondaryAction?: ISessionReadOnlyBannerContent["action"];
 }
 /**
  * A small, self-contained status banner for the current chat. It mirrors the
@@ -34,10 +36,10 @@ export declare class SessionReadOnlyBanner extends Disposable {
     private readonly _icon;
     private readonly _text;
     private readonly _announcement;
-    private readonly _actionContainer;
-    private readonly _actionDisposables;
-    constructor();
+    private readonly _actions;
+    constructor(instantiationService: IInstantiationService);
     get visible(): boolean;
     setVisible(visible: boolean): void;
     setContent(content: ISessionReadOnlyBannerContent): void;
+    private _runAction;
 }

package/vscode/src/vs/sessions/browser/parts/sessionReadOnlyBanner.js

@@ -1,20 +1,22 @@
 
 import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import * as sessionReadOnlyBanner from './media/sessionReadOnlyBanner.css';
-import { $, append, clearNode, addDisposableListener, EventType, EventHelper } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { $, append, clearNode } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
 import { renderIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/iconLabel/iconLabels';
-import { StandardKeyboardEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/keyboardEvent';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
-import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
-import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { Link } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/browser/link';
 
 registerCss(sessionReadOnlyBanner, 0);
-class SessionReadOnlyBanner extends Disposable {
-    constructor() {
+let SessionReadOnlyBanner = class SessionReadOnlyBanner extends Disposable {
+    constructor(instantiationService) {
         super();
         this._visible = false;
-        this._actionDisposables = this._register(( new DisposableStore()));
+        this._actions = [];
         this.domNode = $(".session-readonly-banner");
         this.domNode.setAttribute("role", "status");
         this._icon = append(this.domNode, $(".session-readonly-banner-icon"));
@@ -22,9 +24,25 @@ class SessionReadOnlyBanner extends Disposable {
         this._text = append(this.domNode, $("span.session-readonly-banner-text"));
         this._text.setAttribute("aria-hidden", "true");
         this._announcement = append(this.domNode, $("span.session-readonly-banner-announcement"));
-        this._actionContainer = append(this.domNode, $("span.session-readonly-banner-action"));
+        for (let i = 0; i < 2; i++) {
+            const container = append(this.domNode, $("span.session-readonly-banner-action"));
+            const action = {
+                container,
+                link: this._register(instantiationService.createInstance(Link, container, {
+                    label: "",
+                    href: "#"
+                }, {
+                    opener: () => {
+                        void this._runAction(action).catch(onUnexpectedError);
+                    }
+                })),
+                action: undefined,
+                running: undefined
+            };
+            this._actions.push(action);
+        }
         this.setContent({
-            message: ( localize(3036, "This chat is read-only"))
+            message: ( localize(3437, "This chat is read-only"))
         });
         this.setVisible(false);
     }
@@ -43,27 +61,39 @@ class SessionReadOnlyBanner extends Disposable {
         if (this._announcement.textContent !== announced) {
             this._announcement.textContent = announced;
         }
-        this._actionDisposables.clear();
-        clearNode(this._actionContainer);
-        if (content.action) {
-            const link = append(this._actionContainer, $("a.session-readonly-banner-action-link"));
-            link.textContent = content.action.label;
-            link.setAttribute("role", "button");
-            link.tabIndex = 0;
-            const run = content.action.run;
-            this._actionDisposables.add(addDisposableListener(link, EventType.CLICK, e => {
-                EventHelper.stop(e, true);
-                run();
-            }));
-            this._actionDisposables.add(addDisposableListener(link, EventType.KEY_DOWN, e => {
-                const event = ( new StandardKeyboardEvent(e));
-                if (event.equals(KeyCode.Enter) || event.equals(KeyCode.Space)) {
-                    EventHelper.stop(e, true);
-                    run();
+        for (const [index, action] of [content.action, content.secondaryAction].entries()) {
+            const control = this._actions[index];
+            control.container.hidden = !action;
+            control.container.style.display = action ? "" : "none";
+            if (control.action?.label !== action?.label) {
+                control.link.link = {
+                    label: action?.label ?? "",
+                    href: "#"
+                };
+            }
+            control.action = action;
+            control.link.enabled = !!action && control.running !== action;
+        }
+    }
+    async _runAction(control) {
+        const action = control.action;
+        if (!action || control.running === action) {
+            return;
+        }
+        control.running = action;
+        control.link.enabled = false;
+        try {
+            await action.run();
+        } finally {
+            if (control.running === action) {
+                control.running = undefined;
+                if (!this._store.isDisposed) {
+                    control.link.enabled = !!control.action;
                 }
-            }));
+            }
         }
     }
-}
+};
+SessionReadOnlyBanner = ( __decorate([( __param(0, IInstantiationService))], SessionReadOnlyBanner));
 
 export { SessionReadOnlyBanner };

package/vscode/src/vs/sessions/browser/parts/sessionRemoteConnection.d.ts

@@ -13,6 +13,8 @@ export declare class SessionRemoteConnection extends Disposable {
     private readonly _logService;
     private readonly _session;
     private readonly _attempt;
+    private readonly _connectionAttemptObserved;
+    private readonly _inputReceived;
     private readonly _progressListener;
     private readonly _deadlineSignal;
     private readonly _reconnectCountdownSignal;
@@ -58,9 +60,11 @@ export declare class SessionRemoteConnection extends Disposable {
     private readonly _reconnectCountdownSeconds;
     readonly bannerContent: IObservable<ISessionReadOnlyBannerContent | undefined>;
     readonly recoveryContent: IObservable<IRemoteHostUnavailableEmptyStateContent | undefined>;
+    readonly isQuiet: IObservable<boolean>;
     constructor(_sessionsProvidersService: ISessionsProvidersService, _logService: ILogService);
     setSession(session: IActiveSession | undefined): void;
     connect(): void;
+    connectOnInput(): void;
     private _runConnect;
     private _finishAttempt;
     private _failAttempt;