@codingame/monaco-vscode-chat-service-override 37.2.0 → 37.3.0

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/sandboxPicker.d.ts

@@ -0,0 +1,26 @@
+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 { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IActiveSession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+/**
+ * "Sandbox" checkbox for a new cloud session: when checked, the session runs in a GitHub-managed
+ * sandbox this client drives over the Agent Host Protocol, instead of the server-run cloud agent.
+ *
+ * Disabled rather than hidden without a repository, since a sandbox is always provisioned
+ * against one.
+ */
+export declare class SandboxPicker extends Disposable {
+    private readonly _session;
+    private readonly _configurationService;
+    private readonly _sessionsProvidersService;
+    private readonly _telemetryService;
+    private readonly _chip;
+    private _hasRepository;
+    constructor(_session: IObservable<IActiveSession | undefined>, _configurationService: IConfigurationService, _sessionsProvidersService: ISessionsProvidersService, _telemetryService: ITelemetryService);
+    private _getSession;
+    private _applyToggle;
+    render(container: HTMLElement): void;
+    private _update;
+}

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/sandboxPicker.js

@@ -0,0 +1,86 @@
+
+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 '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { CloudSandboxEnabledSettingId, isCloudSandboxEnabled } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/cloudSandboxAgentHost';
+import { RemoteAgentHostsEnabledSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { CheckboxChip } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/checkboxChip';
+import { reportNewChatPickerClosed } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/newChatPickerTelemetry';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { RemoteNewSession, CopilotChatSessionsProvider } from './copilotChatSessionsProvider.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+let SandboxPicker = class SandboxPicker extends Disposable {
+    constructor(
+        _session,
+        _configurationService,
+        _sessionsProvidersService,
+        _telemetryService
+    ) {
+        super();
+        this._session = _session;
+        this._configurationService = _configurationService;
+        this._sessionsProvidersService = _sessionsProvidersService;
+        this._telemetryService = _telemetryService;
+        this._hasRepository = false;
+        this._chip = this._register(( new CheckboxChip({
+            label: ( localize(4253, "Sandbox")),
+            ariaLabel: ( localize(4254, "Run in a GitHub-managed sandbox")),
+            onToggle: checked => this._applyToggle(checked),
+            slotClassName: "sessions-chat-sandbox-checkbox"
+        })));
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(CloudSandboxEnabledSettingId) || e.affectsConfiguration(RemoteAgentHostsEnabledSettingId)) {
+                this._update();
+            }
+        }));
+        this._register(autorun(reader => {
+            const session = this._session.read(reader);
+            const providerSession = session ? this._getSession(session) : undefined;
+            providerSession?.useSandbox.read(reader);
+            this._hasRepository = providerSession instanceof RemoteNewSession && !!providerSession.repoNwo;
+            this._update();
+        }));
+    }
+    _getSession(session) {
+        const provider = this._sessionsProvidersService.getProvider(session.providerId);
+        return provider instanceof CopilotChatSessionsProvider ? provider.getSession(session.sessionId) : undefined;
+    }
+    _applyToggle(checked) {
+        const session = this._session.get();
+        const providerSession = session ? this._getSession(session) : undefined;
+        if (!providerSession) {
+            return;
+        }
+        reportNewChatPickerClosed(this._telemetryService, {
+            id: "NewChatSandboxPicker",
+            name: "NewChatSandboxPicker",
+            optionIdBefore: String(providerSession.useSandbox.get() === true),
+            optionIdAfter: String(checked),
+            optionLabelBefore: undefined,
+            optionLabelAfter: undefined,
+            isPII: false
+        });
+        providerSession.setUseSandbox(checked);
+    }
+    render(container) {
+        this._chip.render(container);
+        this._update();
+    }
+    _update() {
+        const session = this._session.get();
+        const providerSession = session ? this._getSession(session) : undefined;
+        const enabled = isCloudSandboxEnabled(this._configurationService);
+        this._chip.update({
+            checked: enabled && providerSession?.useSandbox.get() === true,
+            state: !enabled ? "hidden" : this._hasRepository ? "enabled" : "disabled",
+            disabledReason: this._hasRepository ? undefined : ( localize(4255, "A repository is required to run in a sandbox"))
+        });
+    }
+};
+SandboxPicker = ( __decorate([( __param(1, IConfigurationService)), ( __param(2, ISessionsProvidersService)), ( __param(3, ITelemetryService))], SandboxPicker));
+
+export { SandboxPicker };

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/cloudSandboxAgentHost.contribution.d.ts

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

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/cloudSandboxAgentHost.contribution.js

@@ -0,0 +1,14 @@
+
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/cloudSandboxAgentHostService';
+import { CloudSandboxAgentHostContribution } from './cloudSandboxAgentHostContribution.js';
+import '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/cloudSandboxApiService';
+import '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/cloudSandboxTelemetry';
+
+registerWorkbenchContribution2(
+    CloudSandboxAgentHostContribution.ID,
+    CloudSandboxAgentHostContribution,
+    WorkbenchPhase.AfterRestored
+);

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/cloudSandboxAgentHostContribution.d.ts

@@ -0,0 +1,166 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { type ICloudSandboxConnectOptions, type ICloudSandboxCreateSessionRequest, type ICloudSandboxCreatedSession } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/cloudSandboxAgentHost";
+import { ICloudSandboxAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/cloudSandboxAgentHost.service";
+import { ICloudSandboxApiService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/cloudSandboxAgentHost.service";
+import { IRemoteAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IAuthenticationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
+import { IAgentHostFilterService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/agentHostFilter/common/agentHostFilter.service";
+import { ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+import { IRemoteAgentHostSessionsProviderConfig } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostSessionsProvider";
+import { CloudSandboxSessionsProvider } from "./cloudSandboxSessionsProvider.js";
+import { IRemoteAgentHostConnectionCustomizationService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostConnectionCustomization.service";
+/**
+ * A sandbox session that has just been created, connected, and surfaced on its provider — enough
+ * for the caller to send the first turn into it.
+ */
+export interface ICloudSandboxProvisionedSession extends ICloudSandboxCreatedSession {
+    readonly provider: CloudSandboxSessionsProvider;
+    readonly session: ISession;
+}
+export declare class CloudSandboxAgentHostContribution extends Disposable implements IWorkbenchContribution {
+    private readonly _cloudSandboxService;
+    private readonly _apiService;
+    private readonly _remoteAgentHostService;
+    private readonly _connectionCustomizations;
+    private readonly _sessionsProvidersService;
+    private readonly _agentHostFilterService;
+    private readonly _configurationService;
+    private readonly _authenticationService;
+    private readonly _instantiationService;
+    private readonly _notificationService;
+    private readonly _chatSessionsService;
+    private readonly _logService;
+    static readonly ID = "workbench.contrib.cloudSandboxAgentHost";
+    /** Provider instances keyed by connection address (`cloudsandbox:<envId>`). */
+    private readonly _providerInstances;
+    private readonly _providerStores;
+    /** Environment metadata keyed by connection address, for on-demand reconnect. */
+    private readonly _environments;
+    /** In-flight connects keyed by address, so concurrent opens share one attempt. */
+    private readonly _pendingConnects;
+    /**
+     * Addresses being provisioned right now. A task we just created is not yet visible to a
+     * discovery pass that started before it existed, so reconciliation would see a brand-new
+     * environment as one that has vanished and tear it down mid-provision.
+     */
+    private readonly _provisioning;
+    /**
+     * Read-only content providers standing in for unreachable environments, keyed by session type.
+     * Disposed when the environment becomes reachable again.
+     */
+    private readonly _readOnlyHandlers;
+    /**
+     * Cancelled when the feature is disabled (or the contribution is disposed), so in-flight
+     * discovery and connects abort instead of committing state after teardown has run.
+     */
+    private _enabledCts;
+    /** Serializes discovery so overlapping triggers can't interleave reconciliation. */
+    private _discoveryInFlight;
+    private _discoveryQueued;
+    /** Whether discovery has completed at least once, used to stop the auth-driven retry. */
+    private _hasDiscovered;
+    /**
+     * Keeps the "GitHub Sandboxes" filter entry present for as long as the feature is on, so the
+     * place is visible and selectable before the user has any sandbox session to put in it.
+     */
+    private readonly _hostGroupRegistration;
+    constructor(_cloudSandboxService: ICloudSandboxAgentHostService, _apiService: ICloudSandboxApiService, _remoteAgentHostService: IRemoteAgentHostService, _connectionCustomizations: IRemoteAgentHostConnectionCustomizationService, _sessionsProvidersService: ISessionsProvidersService, _agentHostFilterService: IAgentHostFilterService, _configurationService: IConfigurationService, _authenticationService: IAuthenticationService, _instantiationService: IInstantiationService, _notificationService: INotificationService, _chatSessionsService: IChatSessionsService, _logService: ILogService);
+    /**
+     * Discover environment-bound sandbox sessions and seed them into per-environment providers so
+     * they appear in the sessions list **without** connecting. Reconciles against the result:
+     * environments that have vanished from discovery (e.g. their task was archived) and are not
+     * currently connected are torn down, so stale providers/sessions don't linger. Best-effort:
+     * a failed discovery is logged and leaves existing state untouched.
+     *
+     * Runs are serialized, with at most one follow-up queued, so overlapping triggers can't
+     * interleave their reconciliation passes.
+     */
+    private _discoverAndSeed;
+    private _doDiscoverAndSeed;
+    /**
+     * Remove the connection (and its credential refresher) for an environment while keeping the
+     * provider and its cached sessions visible in a disconnected state. Disposing the protocol
+     * client stops its soft-reconnect loop and disposes the credential refresher owned by its
+     * connection factory.
+     */
+    private _disconnectEnvironment;
+    /**
+     * Provision a brand-new sandbox session and make it usable: create the Mission Control task,
+     * seed it into a per-environment provider, and connect the relay.
+     *
+     * From the seed onward this matches {@link _doDiscoverAndSeed}, so a later discovery pass
+     * reconciles against the session instead of duplicating it. The caller sends the first turn.
+     */
+    provisionSession(request: ICloudSandboxCreateSessionRequest, token: CancellationToken): Promise<ICloudSandboxProvisionedSession>;
+    /**
+     * Fully tear down an environment: dispose its provider (unregistering it and its sessions) and
+     * remove its connection + credential refresher. Used when an environment vanishes from discovery
+     * or the feature is disabled.
+     */
+    private _teardownEnvironment;
+    /** Tear down every known sandbox environment (feature disabled). */
+    private _teardownAll;
+    /** Map each known sandbox connection authority to its address (`cloudsandbox:<envId>`). */
+    private _authoritiesByAddress;
+    /** Resolve the sandbox address owning a remote-agent-host session type, if any. */
+    private _findAddressForSessionType;
+    /** Opens an online environment through its host, or an offline session from persisted history. */
+    protected _waitForActivation(sessionType: string): Promise<boolean>;
+    /** An unreadable record must not trigger an automatic resume. */
+    private _isEnvironmentOnline;
+    /** Reads history from Mission Control without connecting to the sandbox. */
+    private _fetchTaskHistory;
+    /**
+     * Register a content provider that serves this session from replayed history, read-only.
+     *
+     * Only ever registered when the environment is not connected — dormant, or a connect that just
+     * failed — so the transcript is real but there is nothing to send to. A connect that later
+     * lands drops this stand-in and hands the session to the live handler.
+     *
+     * Returns `true` once registered, which is what lets `canResolveChatSession` proceed, or
+     * `false` when there is no task to read history from.
+     */
+    private _activateReadOnly;
+    /**
+     * Drop any read-only stand-in for an address so the live handler can own the session type.
+     * Registering two content providers for one session type throws, so this must run before a
+     * connection is established rather than after.
+     */
+    private _clearReadOnly;
+    /**
+     * Ensure a provider exists for the environment and establish (or reuse) the
+     * connection. Resolves with the connection's display address.
+     */
+    connect(options: ICloudSandboxConnectOptions): Promise<string>;
+    /**
+     * Return a provider to a state the user can act on after its connect failed. Defers to the
+     * service when it has something live to report, so a failure that raced a successful dial does
+     * not overwrite a good status, and leaves `incompatible` alone since redialing cannot fix it.
+     */
+    private _settleFailedConnect;
+    private _isEnabled;
+    /**
+     * Keep the host filter entry in step with the feature toggles. The entry stands on its own —
+     * it is there whether or not discovery has found any environment — so a user with the feature
+     * on but no tasks yet can still see and select the place their sandboxes will appear in.
+     */
+    private _updateHostGroupRegistration;
+    /** Create the sessions provider for an environment if it doesn't exist yet. */
+    private _ensureProvider;
+    /**
+     * Provider construction seam so tests can observe each provider's configuration.
+     */
+    protected _instantiateProvider(config: IRemoteAgentHostSessionsProviderConfig): CloudSandboxSessionsProvider;
+    /** Wire each live connection to its provider so session enumeration runs. */
+    private _wireConnections;
+    /** Push the service's authoritative connection status onto each provider. */
+    private _updateConnectionStatuses;
+}