@codingame/monaco-vscode-api 37.3.3 → 37.3.5

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

@@ -0,0 +1,301 @@
+
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import '../../../../../base/common/observableInternal/index.js';
+import { isEqual } from '../../../../../base/common/resources.js';
+import { localize } from '../../../../../nls.js';
+import { AgentSessionProviders } from '../../../../../workbench/contrib/chat/browser/agentSessions/agentSessions.js';
+import { IGitService } from '../../../../../workbench/contrib/git/common/gitService.service.js';
+import { gitHubInfoEqual, BRANCH_CHANGES_CHANGESET_ID, sessionFileChangesEqual } from '../../../../services/sessions/common/session.js';
+import { IGitHubService } from '../../../github/browser/githubService.service.js';
+import { toPRContentUri } from '../../../github/common/utils.js';
+import { constObservable } from '../../../../../base/common/observableInternal/observables/constObservable.js';
+import { derivedOpts, derived } from '../../../../../base/common/observableInternal/observables/derived.js';
+import { ObservablePromise } from '../../../../../base/common/observableInternal/utils/promise.js';
+
+let GitRepositoryChangesetResolver = class GitRepositoryChangesetResolver {
+    constructor(workspace, _gitService) {
+        this._gitService = _gitService;
+        this._repositoryUriObs = derivedOpts({
+            equalsFn: isEqual
+        }, reader => {
+            const gitRepository = workspace.read(reader)?.folders[0].gitRepository;
+            return gitRepository?.workTreeUri ?? gitRepository?.uri;
+        });
+    }
+    async resolve(firstCheckpointRef, lastCheckpointRef) {
+        const repositoryUri = this._repositoryUriObs.get();
+        if (!repositoryUri) {
+            return [];
+        }
+        const repository = await this._gitService.openRepository(repositoryUri);
+        const ref = lastCheckpointRef ? `${firstCheckpointRef}..${lastCheckpointRef}` : firstCheckpointRef;
+        const changes = (await repository?.diffBetweenWithStats2(ref)) ?? [];
+        return toIChatSessionFileChange2(changes, firstCheckpointRef, lastCheckpointRef);
+    }
+};
+GitRepositoryChangesetResolver = ( __decorate([( __param(1, IGitService))], GitRepositoryChangesetResolver));
+let GitHubRepositoryChangesetResolver = class GitHubRepositoryChangesetResolver {
+    constructor(workspace, _gitHubService) {
+        this._gitHubService = _gitHubService;
+        this._gitHubInfoObs = derivedOpts({
+            equalsFn: gitHubInfoEqual
+        }, reader => {
+            const gitRepository = workspace.read(reader)?.folders[0].gitRepository;
+            return gitRepository?.gitHubInfo.read(reader);
+        });
+    }
+    async resolve(firstCheckpointRef, lastCheckpointRef) {
+        const gitHubInfo = this._gitHubInfoObs.get();
+        if (!gitHubInfo || !gitHubInfo.pullRequest?.number) {
+            return undefined;
+        }
+        const params = {
+            owner: gitHubInfo.owner,
+            repo: gitHubInfo.repo,
+            prNumber: gitHubInfo.pullRequest.number
+        };
+        const changes = await this._gitHubService.getChangedFiles(params.owner, params.repo, firstCheckpointRef, lastCheckpointRef);
+        return changes.map(change => {
+            const uri = toPRContentUri(change.filename, {
+                ...params,
+                commitSha: lastCheckpointRef,
+                status: change.status,
+                isBase: false
+            });
+            const originalUri = change.status !== "added" ? toPRContentUri(change.previous_filename || change.filename, {
+                ...params,
+                commitSha: firstCheckpointRef,
+                previousFileName: change.previous_filename,
+                status: change.status,
+                isBase: true
+            }) : undefined;
+            const modifiedUri = change.status !== "removed" ? uri : undefined;
+            return {
+                uri,
+                originalUri,
+                modifiedUri,
+                insertions: change.additions,
+                deletions: change.deletions
+            };
+        });
+    }
+};
+GitHubRepositoryChangesetResolver = ( __decorate([( __param(1, IGitHubService))], GitHubRepositoryChangesetResolver));
+function createChangesets(sessionType, workspaceObs, chatsObs, instantiationService) {
+    const changesetResolver = sessionType === AgentSessionProviders.Cloud ? instantiationService.createInstance(GitHubRepositoryChangesetResolver, workspaceObs) : instantiationService.createInstance(GitRepositoryChangesetResolver, workspaceObs);
+    const changesets = [( new BranchChangesChangeset(workspaceObs, chatsObs))];
+    if (sessionType !== AgentSessionProviders.Cloud) {
+        changesets.push(( new UncommittedChangesChangeset(workspaceObs, chatsObs, changesetResolver)));
+    }
+    changesets.push(( new AllChangesChangeset(chatsObs, changesetResolver)));
+    changesets.push(( new LastTurnChangesChangeset(chatsObs, changesetResolver)));
+    return constObservable(changesets);
+}
+class AbstractChangeset {
+    constructor(_chats) {
+        this._chats = _chats;
+        this.operations = constObservable([]);
+    }
+    async invokeOperation(_operationId, _target) {}
+}
+class BranchChangesChangeset extends AbstractChangeset {
+    static {
+        this.ID = BRANCH_CHANGES_CHANGESET_ID;
+    }
+    constructor(workspaceObs, chatsObs) {
+        super(chatsObs);
+        this.id = BranchChangesChangeset.ID;
+        this.label = ( localize(4321, "Branch Changes"));
+        this.category = ( localize(4322, "Changes"));
+        this.isLoadingChanges = constObservable(false);
+        this.modifiedCheckpointRef = constObservable(undefined);
+        const gitRepository = workspaceObs.get()?.folders[0].gitRepository;
+        const branchName = gitRepository?.branchName;
+        const baseBranchName = gitRepository?.baseBranchName;
+        this.description = branchName && baseBranchName ? `${branchName} → ${baseBranchName}` : branchName;
+        this.originalCheckpointRef = derived(reader => {
+            return chatsObs.read(reader)[0]?.checkpoints.read(reader)?.firstCheckpointRef;
+        });
+        const isArchivedObs = derived(reader => chatsObs.read(reader)[0]?.isArchived.read(reader) === true);
+        this.isDefault = derived(reader => !isArchivedObs.read(reader));
+        this.isEnabled = derived(reader => !isArchivedObs.read(reader));
+        this.changes = derived(reader => {
+            return chatsObs.read(reader)[0]?.changes.read(reader) ?? [];
+        });
+    }
+}
+class UncommittedChangesChangeset extends AbstractChangeset {
+    static {
+        this.ID = "uncommittedChanges";
+    }
+    constructor(workspaceObs, chatsObs, changesetResolver) {
+        super(chatsObs);
+        this.id = UncommittedChangesChangeset.ID;
+        this.label = ( localize(4323, "Uncommitted Changes"));
+        this.description = ( localize(4324, "Show uncommitted changes in this session"));
+        this.category = ( localize(4322, "Changes"));
+        this.isDefault = constObservable(false);
+        this.originalCheckpointRef = constObservable("HEAD");
+        this.modifiedCheckpointRef = constObservable(undefined);
+        this.isEnabled = derived(reader => chatsObs.read(reader)[0]?.isArchived.read(reader) !== true);
+        const uncommittedChangesCountObs = derived(reader => {
+            const gitRepository = workspaceObs.read(reader)?.folders[0].gitRepository;
+            return gitRepository?.uncommittedChanges ?? 0;
+        });
+        const changesPromiseObs = derived(reader => {
+            const originalCheckpointRef = this.originalCheckpointRef.read(reader);
+            const modifiedCheckpointRef = this.modifiedCheckpointRef.read(reader);
+            uncommittedChangesCountObs.read(reader);
+            const diffPromise = changesetResolver.resolve(originalCheckpointRef, modifiedCheckpointRef);
+            return ( new ObservablePromise(diffPromise)).resolvedValue;
+        });
+        this.isLoadingChanges = derived(reader => {
+            return changesPromiseObs.read(reader).read(reader) === undefined;
+        });
+        this.changes = derivedOpts({
+            equalsFn: sessionFileChangesEqual
+        }, reader => {
+            return changesPromiseObs.read(reader).read(reader) ?? [];
+        });
+    }
+}
+class AllChangesChangeset extends AbstractChangeset {
+    static {
+        this.ID = "allChanges";
+    }
+    constructor(chatsObs, changesetResolver) {
+        super(chatsObs);
+        this.id = AllChangesChangeset.ID;
+        this.label = ( localize(4325, "All Changes"));
+        this.description = ( localize(4326, "Show all changes made in this session"));
+        this.category = ( localize(4327, "Checkpoints"));
+        this.originalCheckpointRef = derived(reader => {
+            return chatsObs.read(reader)[0]?.checkpoints.read(reader)?.firstCheckpointRef;
+        });
+        this.modifiedCheckpointRef = derived(reader => {
+            const chats = chatsObs.read(reader);
+            if (chats.length === 0) {
+                return undefined;
+            }
+            if (chats.length === 1) {
+                return chats[0].checkpoints.read(reader)?.lastCheckpointRef;
+            }
+            const chatsSortedByLastTurnEnd = chats.toSorted((chatA, chatB) => {
+                const chatALastTurnEnd = chatA.lastTurnEnd.read(reader);
+                const chatBLastTurnEnd = chatB.lastTurnEnd.read(reader);
+                return sortDateDesc(chatALastTurnEnd, chatBLastTurnEnd);
+            });
+            return chatsSortedByLastTurnEnd[0].checkpoints.read(reader)?.lastCheckpointRef;
+        });
+        const changesPromiseObs = derived(reader => {
+            const originalCheckpointRef = this.originalCheckpointRef.read(reader);
+            const modifiedCheckpointRef = this.modifiedCheckpointRef.read(reader);
+            if (!originalCheckpointRef || !modifiedCheckpointRef) {
+                return constObservable([]);
+            }
+            const diffPromise = changesetResolver.resolve(originalCheckpointRef, modifiedCheckpointRef);
+            return ( new ObservablePromise(diffPromise)).resolvedValue;
+        });
+        this.isLoadingChanges = derived(reader => {
+            return changesPromiseObs.read(reader).read(reader) === undefined;
+        });
+        this.changes = derivedOpts({
+            equalsFn: sessionFileChangesEqual
+        }, reader => {
+            return changesPromiseObs.read(reader).read(reader) ?? [];
+        });
+        this.isDefault = derived(reader => chatsObs.read(reader)[0]?.isArchived.read(reader) === true);
+        this.isEnabled = derived(
+            reader => this.originalCheckpointRef.read(reader) !== undefined && this.modifiedCheckpointRef.read(reader) !== undefined
+        );
+    }
+}
+class LastTurnChangesChangeset extends AbstractChangeset {
+    static {
+        this.ID = "lastTurnChanges";
+    }
+    constructor(chatsObs, changesetResolver) {
+        super(chatsObs);
+        this.id = LastTurnChangesChangeset.ID;
+        this.label = ( localize(4328, "Last Turn Changes"));
+        this.description = ( localize(4329, "Show only changes made in the last turn"));
+        this.category = ( localize(4327, "Checkpoints"));
+        this.isDefault = constObservable(false);
+        this.modifiedCheckpointRef = derived(reader => {
+            const chats = chatsObs.read(reader);
+            if (chats.length === 0) {
+                return undefined;
+            }
+            if (chats.length === 1) {
+                return chats[0].checkpoints.read(reader)?.lastCheckpointRef;
+            }
+            const chatsSortedByLastTurnEnd = chats.toSorted((chatA, chatB) => {
+                const chatALastTurnEnd = chatA.lastTurnEnd.read(reader);
+                const chatBLastTurnEnd = chatB.lastTurnEnd.read(reader);
+                return sortDateDesc(chatALastTurnEnd, chatBLastTurnEnd);
+            });
+            return chatsSortedByLastTurnEnd[0].checkpoints.read(reader)?.lastCheckpointRef;
+        });
+        this.originalCheckpointRef = derived(reader => {
+            const modifiedCheckpointRef = this.modifiedCheckpointRef.read(reader);
+            return modifiedCheckpointRef ? `${modifiedCheckpointRef}^` : undefined;
+        });
+        const changesPromiseObs = derived(reader => {
+            const originalCheckpointRef = this.originalCheckpointRef.read(reader);
+            const modifiedCheckpointRef = this.modifiedCheckpointRef.read(reader);
+            if (!originalCheckpointRef || !modifiedCheckpointRef) {
+                return constObservable([]);
+            }
+            const diffPromise = changesetResolver.resolve(originalCheckpointRef, modifiedCheckpointRef);
+            return ( new ObservablePromise(diffPromise)).resolvedValue;
+        });
+        this.isLoadingChanges = derived(reader => {
+            return changesPromiseObs.read(reader).read(reader) === undefined;
+        });
+        this.changes = derivedOpts({
+            equalsFn: sessionFileChangesEqual
+        }, reader => {
+            return changesPromiseObs.read(reader).read(reader) ?? [];
+        });
+        this.isEnabled = derived(
+            reader => this.originalCheckpointRef.read(reader) !== undefined && this.modifiedCheckpointRef.read(reader) !== undefined
+        );
+    }
+}
+function sortDateDesc(dateA, dateB) {
+    const chatALastTurnEnd = dateA?.getTime();
+    const chatBLastTurnEnd = dateB?.getTime();
+    if (!chatALastTurnEnd && !chatBLastTurnEnd) {
+        return 0;
+    }
+    if (!chatALastTurnEnd) {
+        return 1;
+    }
+    if (!chatBLastTurnEnd) {
+        return -1;
+    }
+    return chatBLastTurnEnd - chatALastTurnEnd;
+}
+function toIChatSessionFileChange2(changes, originalRef, modifiedRef) {
+    return changes.map(change => ({
+        uri: change.uri,
+        originalUri: change.originalUri ? originalRef ? change.originalUri.with({
+            scheme: "git",
+            query: JSON.stringify({
+                path: change.originalUri.fsPath,
+                ref: originalRef
+            })
+        }) : change.originalUri : undefined,
+        modifiedUri: change.modifiedUri ? modifiedRef ? change.modifiedUri.with({
+            scheme: "git",
+            query: JSON.stringify({
+                path: change.modifiedUri.fsPath,
+                ref: modifiedRef
+            })
+        }) : change.modifiedUri : undefined,
+        insertions: change.insertions,
+        deletions: change.deletions
+    }));
+}
+
+export { AllChangesChangeset, BranchChangesChangeset, LastTurnChangesChangeset, UncommittedChangesChangeset, createChangesets };

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

@@ -0,0 +1,166 @@
+import { CancellationToken } from "../../../../../base/common/cancellation.js";
+import { Disposable } from "../../../../../base/common/lifecycle.js";
+import { type ICloudSandboxConnectOptions, type ICloudSandboxCreateSessionRequest, type ICloudSandboxCreatedSession } from "../../../../../platform/agentHost/common/cloudSandboxAgentHost.js";
+import { ICloudSandboxAgentHostService } from "../../../../../platform/agentHost/common/cloudSandboxAgentHost.service.js";
+import { ICloudSandboxApiService } from "../../../../../platform/agentHost/common/cloudSandboxAgentHost.service.js";
+import { IRemoteAgentHostService } from "../../../../../platform/agentHost/common/remoteAgentHostService.service.js";
+import { IConfigurationService } from "../../../../../platform/configuration/common/configuration.service.js";
+import { IAuthenticationService } from "../../../../../workbench/services/authentication/common/authentication.service.js";
+import { IInstantiationService } from "../../../../../platform/instantiation/common/instantiation.js";
+import { ILogService } from "../../../../../platform/log/common/log.service.js";
+import { INotificationService } from "../../../../../platform/notification/common/notification.service.js";
+import { IWorkbenchContribution } from "../../../../../workbench/common/contributions.js";
+import { IChatSessionsService } from "../../../../../workbench/contrib/chat/common/chatSessionsService.service.js";
+import { IAgentHostFilterService } from "../../../../services/agentHostFilter/common/agentHostFilter.service.js";
+import { ISession } from "../../../../services/sessions/common/session.js";
+import { ISessionsProvidersService } from "../../../../services/sessions/browser/sessionsProvidersService.service.js";
+import { IRemoteAgentHostSessionsProviderConfig } from "./remoteAgentHostSessionsProvider.js";
+import { CloudSandboxSessionsProvider } from "./cloudSandboxSessionsProvider.js";
+import { IRemoteAgentHostConnectionCustomizationService } from "./remoteAgentHostConnectionCustomization.service.js";
+/**
+ * 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;
+}