@codingame/monaco-vscode-chat-cloud-service-override 0.0.0-stage → 38.0.7

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

@@ -0,0 +1,620 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Sequencer, Limiter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { isCancellationError, CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isObject } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IDefaultAccountService } from '@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.service';
+import { toAbortSignal } from '@codingame/monaco-vscode-api/vscode/vs/platform/github/common/cancellation';
+import { MutationUncertainError, ApiRequestError } from '@codingame/monaco-vscode-api/vscode/vs/platform/github/common/missionControl/missionControlClient';
+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 { IWorkbenchGitHubService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/github/common/githubService.service';
+import { ISessionsRecentWorkspacesService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsRecentWorkspacesService.service';
+import { GITHUB_REMOTE_FILE_SCHEME } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { constObservable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/constObservable';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+
+const REPOSITORIES_STORAGE_KEY = "cloudAutomations.repositories";
+let GitHubCloudAutomationStore = class GitHubCloudAutomationStore extends Disposable {
+    constructor(
+        resolveRepositoryUri,
+        gitHubService,
+        defaultAccountService,
+        storageService,
+        logService,
+        recentWorkspacesService
+    ) {
+        super();
+        this.resolveRepositoryUri = resolveRepositoryUri;
+        this.gitHubService = gitHubService;
+        this.defaultAccountService = defaultAccountService;
+        this.storageService = storageService;
+        this.logService = logService;
+        this.recentWorkspacesService = recentWorkspacesService;
+        this.cachedEntries = observableValue(this, []);
+        this.entries = this.cachedEntries;
+        this.state = observableValue(this, "ready");
+        this.catalogueState = this.state;
+        this.lifetime = ( new AbortController());
+        this.clientStore = this._register(( new DisposableStore()));
+        this.operations = ( new Sequencer());
+        this.cachedHistory = observableValue(this, []);
+        this.history = this.cachedHistory;
+        this.uncertain = observableValue(this, false);
+        this.mutationUncertain = this.uncertain;
+        this.targetEligibility = ( new Map());
+        this.targetEligibilityLimiter = this._register(( new Limiter(5)));
+        this.cachedTools = observableValue(this, undefined);
+        this.toolCatalog = this.cachedTools;
+        this._register(defaultAccountService.onDidChangeDefaultAccount(() => this.reset()));
+        this._register(gitHubService.onDidChangeDefaultClient(() => this.reset()));
+        this.reset();
+    }
+    getWorkspaceTarget(workspace) {
+        const required = ( localize(5091, "Choose a private GitHub.com repository."));
+        if (!workspace || this._store.isDisposed || this.lifetime.signal.aborted) {
+            return constObservable({
+                disabledReason: required
+            });
+        }
+        const key = ( workspace.toString());
+        const cached = this.targetEligibility.get(key);
+        if (cached) {
+            return cached;
+        }
+        const result = observableValue(this, {
+            disabledReason: ( localize(5092, "Checking repository access...")),
+            pending: true
+        });
+        this.targetEligibility.set(key, result);
+        const signal = this.lifetime.signal;
+        void this.targetEligibilityLimiter.queue(async () => {
+            try {
+                this.requireAccount();
+                signal.throwIfAborted();
+                const repository = await this.resolveRepository(workspace);
+                signal.throwIfAborted();
+                const eligible = repository && (await this.withClient(
+                    signal,
+                    async (client, identity, signal) => (await client.query.getRepository({
+                        ...identity,
+                        owner: repository.owner,
+                        repo: repository.name
+                    }, signal)).private
+                ));
+                signal.throwIfAborted();
+                if (this.targetEligibility.get(key) !== result) {
+                    return;
+                }
+                result.set(eligible ? {
+                    workspace: ( URI.from({
+                        scheme: GITHUB_REMOTE_FILE_SCHEME,
+                        authority: "github",
+                        path: `/${repository.owner}/${repository.name}/HEAD`
+                    }))
+                } : {
+                    disabledReason: repository ? ( localize(5093, "This repository must be private")) : required,
+                    isPublicRepository: repository !== undefined
+                }, undefined);
+            } catch (error) {
+                if (!isCancellationError(error)) {
+                    this.logService.warn("[CloudAutomations] Repository eligibility check failed", error);
+                }
+                if (!signal.aborted && !this._store.isDisposed && this.targetEligibility.get(key) === result) {
+                    result.set({
+                        disabledReason: ( localize(
+                            5094,
+                            "Unable to verify repository access. Refresh automations to try again."
+                        ))
+                    }, undefined);
+                }
+            }
+        });
+        return result;
+    }
+    loadTools() {
+        const current = this.cachedTools.get();
+        if (current?.kind === "loading" || current?.kind === "ready") {
+            return;
+        }
+        const signal = this.lifetime.signal;
+        this.cachedTools.set({
+            kind: "loading"
+        }, undefined);
+        void (async () => {
+            try {
+                this.requireAccount();
+                const groups = await this.withClient(
+                    signal,
+                    (client, _identity, signal) => client.automations.listTools(signal)
+                );
+                signal.throwIfAborted();
+                this.cachedTools.set({
+                    kind: "ready",
+                    groups
+                }, undefined);
+            } catch (error) {
+                if (signal.aborted || this._store.isDisposed) {
+                    return;
+                }
+                if (!isCancellationError(error)) {
+                    this.logService.warn("[CloudAutomations] Failed to load automation tools", error);
+                }
+                this.cachedTools.set({
+                    kind: "error"
+                }, undefined);
+            }
+        })();
+    }
+    clearTargetEligibility() {
+        const targets = [...( this.targetEligibility.values())];
+        this.targetEligibility.clear();
+        for (const target of targets) {
+            target.set({
+                disabledReason: ( localize(5095, "Repository access must be verified again."))
+            }, undefined);
+        }
+    }
+    async registerRepository(workspace) {
+        const account = this.requireAccount();
+        const signal = this.lifetime.signal;
+        const repository = await this.resolveRepository(workspace);
+        signal.throwIfAborted();
+        if (!repository) {
+            throw ( new Error(( localize(5096, "Select a GitHub.com repository for this cloud automation."))));
+        }
+        await this.withClient(signal, async (client, identity, signal) => {
+            if (!(await client.query.getRepository({
+                ...identity,
+                owner: repository.owner,
+                repo: repository.name
+            }, signal)).private) {
+                throw ( new Error(( localize(5097, "Cloud automations currently require a private GitHub repository."))));
+            }
+            this.rememberRepositories(account.accountName, [repository], signal);
+        });
+    }
+    async refresh() {
+        const account = this.requireAccount();
+        if (this.refreshPromise) {
+            return this.refreshPromise;
+        }
+        this.clearTargetEligibility();
+        const signal = this.lifetime.signal;
+        this.state.set("loading", undefined);
+        const refresh = this.operations.queue(async () => {
+            await this.withClient(
+                signal,
+                (client, identity, signal) => this.refreshRepositories(account, signal, client, identity)
+            );
+            signal.throwIfAborted();
+            this.uncertain.set(false, undefined);
+        });
+        this.refreshPromise = refresh;
+        try {
+            await refresh;
+        } catch (error) {
+            if (!signal.aborted && !this._store.isDisposed) {
+                this.state.set("error", undefined);
+                this.logService.warn("[CloudAutomations] Failed to refresh repositories", error);
+            }
+            throw error;
+        } finally {
+            if (this.refreshPromise === refresh) {
+                this.refreshPromise = undefined;
+            }
+        }
+    }
+    async acquireClient(signal) {
+        const reference = await this.gitHubService.acquireDefaultAccountClient(signal);
+        try {
+            signal.throwIfAborted();
+            if (reference.object.endpoint.getApiBaseUri() !== "https://api.github.com") {
+                throw ( new Error(( localize(5098, "Cloud automations require a GitHub.com account."))));
+            }
+        } catch (error) {
+            reference.dispose();
+            throw error;
+        }
+        this.clientStore.add(reference);
+        this.clientStore.add(reference.object.onDidInvalidate(() => this.reset()));
+        return reference.object;
+    }
+    async withClient(signal, task) {
+        signal.throwIfAborted();
+        const pending = this.clientPromise ??= this.acquireClient(signal);
+        let client;
+        try {
+            client = await pending;
+        } catch (error) {
+            if (this.clientPromise === pending) {
+                this.clientPromise = undefined;
+            }
+            throw error;
+        }
+        const credential = await client.credentials.getCredential(signal);
+        const operationSignal = AbortSignal.any([signal, credential.signal]);
+        try {
+            operationSignal.throwIfAborted();
+            const result = await task(client, credential.account, operationSignal);
+            operationSignal.throwIfAborted();
+            return result;
+        } catch (error) {
+            if (operationSignal.aborted && !(error instanceof MutationUncertainError || error instanceof ApiRequestError && error.outcome === "indeterminate")) {
+                throw ( new CancellationError());
+            }
+            throw error;
+        }
+    }
+    async create(workspace, value, guard) {
+        const account = this.requireAccount();
+        const signal = this.lifetime.signal;
+        const repository = await this.resolveRepository(workspace);
+        signal.throwIfAborted();
+        if (!repository) {
+            throw ( new Error(( localize(5096, "Select a GitHub.com repository for this cloud automation."))));
+        }
+        return this.mutate(repository, async (client, ref, signal) => {
+            this.rememberRepositories(account.accountName, [repository], signal);
+            guard?.();
+            const definition = await client.automations.create(ref, value, signal);
+            return this.publish(repository, definition, signal);
+        }, CancellationToken.None, signal);
+    }
+    update(entry, patch, guard) {
+        return this.mutate(entry.repository, async (client, ref, signal) => {
+            let current;
+            try {
+                current = await client.automations.get(ref, entry.definition.id, signal);
+            } catch (error) {
+                if (!(error instanceof ApiRequestError) || error.statusCode !== 404) {
+                    throw error;
+                }
+                this.removeEntry(entry, signal);
+                return {
+                    entry: undefined,
+                    updated: false
+                };
+            }
+            this.publish(entry.repository, current, signal);
+            const value = patch(current);
+            if (!value) {
+                return {
+                    entry: {
+                        repository: entry.repository,
+                        definition: current
+                    },
+                    updated: false
+                };
+            }
+            guard?.();
+            const definition = await client.automations.update(ref, current.id, value, signal);
+            return {
+                entry: this.publish(entry.repository, definition, signal),
+                updated: true
+            };
+        });
+    }
+    async delete(entry, guard) {
+        await this.mutate(entry.repository, async (client, ref, signal) => {
+            guard?.();
+            await client.automations.delete(ref, entry.definition.id, signal);
+            this.removeEntry(entry, signal);
+        });
+    }
+    async run(entry, token = CancellationToken.None) {
+        await this.mutate(
+            entry.repository,
+            (client, ref, signal) => client.automations.dispatch(ref, entry.definition.id, {
+                event: "manual"
+            }, signal),
+            token
+        );
+    }
+    async stop(entry) {
+        await this.mutate(
+            entry.entry.repository,
+            (client, _ref, signal) => client.tasks.abort(entry.task.id, signal)
+        );
+    }
+    async refreshHistory() {
+        this.requireAccount();
+        const signal = this.lifetime.signal;
+        await this.operations.queue(async () => {
+            await this.withClient(signal, async (client, _identity, operationSignal) => {
+                const resources = ( new DisposableStore());
+                const controller = ( new AbortController());
+                const historySignal = AbortSignal.any([operationSignal, controller.signal]);
+                const limiter = resources.add(( new Limiter(4)));
+                try {
+                    const history = await Promise.all(this.cachedEntries.get().map(entry => limiter.queue(async () => {
+                        try {
+                            historySignal.throwIfAborted();
+                            const tasks = await client.automations.listRuns(entry.definition.id, historySignal, {
+                                per_page: 50,
+                                page: 1,
+                                sort: "created_at",
+                                direction: "desc",
+                                is_archived: false
+                            }).catch(error => {
+                                if (!(error instanceof ApiRequestError) || error.statusCode !== 404) {
+                                    throw error;
+                                }
+                                this.removeEntry(entry, historySignal);
+                                this.logService.info("[CloudAutomations] Definition no longer available", entry.definition.id);
+                                return undefined;
+                            });
+                            const result = [];
+                            for (const task of tasks?.data.tasks ?? []) {
+                                const detail = ["queued", "in_progress", "running", "waiting_for_user"].includes(task.state) ? await client.tasks.get(task.id, historySignal) : task;
+                                result.push({
+                                    entry,
+                                    task: detail
+                                });
+                            }
+                            return result;
+                        } catch (error) {
+                            controller.abort(( new CancellationError()));
+                            throw error;
+                        }
+                    })));
+                    operationSignal.throwIfAborted();
+                    this.cachedHistory.set(history.flat(), undefined);
+                } finally {
+                    controller.abort(( new CancellationError()));
+                    resources.dispose();
+                }
+            });
+        });
+    }
+    mutate(
+        repository,
+        operation,
+        token = CancellationToken.None,
+        lifetime = this.lifetime.signal
+    ) {
+        this.requireAccount();
+        return this.operations.queue(async () => {
+            lifetime.throwIfAborted();
+            if (this.uncertain.get()) {
+                throw ( new MutationUncertainError("unknown"));
+            }
+            const resources = ( new DisposableStore());
+            try {
+                const signal = AbortSignal.any([lifetime, toAbortSignal(token, resources)]);
+                return await this.withClient(signal, async (client, identity, signal) => {
+                    const ref = {
+                        ...identity,
+                        owner: repository.owner,
+                        repo: repository.name
+                    };
+                    if (!(await client.query.getRepository(ref, signal)).private) {
+                        throw ( new Error(( localize(5097, "Cloud automations currently require a private GitHub repository."))));
+                    }
+                    return operation(client, repository, signal);
+                });
+            } catch (error) {
+                if ((error instanceof MutationUncertainError || error instanceof ApiRequestError && error.outcome === "indeterminate") && !lifetime.aborted) {
+                    this.uncertain.set(true, undefined);
+                }
+                throw error;
+            } finally {
+                resources.dispose();
+            }
+        });
+    }
+    publish(repository, definition, signal) {
+        signal.throwIfAborted();
+        const entry = {
+            repository,
+            definition
+        };
+        this.cachedEntries.set([
+            ...this.cachedEntries.get().filter(candidate => !sameEntry(candidate, entry)),
+            entry
+        ], undefined);
+        return entry;
+    }
+    removeEntry(entry, signal) {
+        signal.throwIfAborted();
+        transaction(tx => {
+            this.cachedEntries.set(
+                this.cachedEntries.get().filter(candidate => !sameEntry(candidate, entry)),
+                tx
+            );
+            this.cachedHistory.set(
+                this.cachedHistory.get().filter(candidate => !sameEntry(candidate.entry, entry)),
+                tx
+            );
+        });
+    }
+    async refreshRepositories(account, signal, client, identity) {
+        const repositories = this.readRepositories(account.accountName);
+        const errors = [];
+        for (const recent of this.recentWorkspacesService.getRecentWorkspaces(false)) {
+            const root = recent.workspace.folders[0]?.root;
+            try {
+                const repository = root && (await this.resolveRepository(root));
+                signal.throwIfAborted();
+                if (repository) {
+                    repositories.set(repositoryKey(repository), repository);
+                }
+            } catch (error) {
+                signal.throwIfAborted();
+                this.logService.warn("[CloudAutomations] Failed to resolve a recent repository", error);
+                errors.push(error);
+            }
+        }
+        const snapshot = ( new Map());
+        for (const entry of this.cachedEntries.get()) {
+            const key = repositoryKey(entry.repository);
+            snapshot.set(key, [...(snapshot.get(key) ?? []), entry]);
+        }
+        const eligible = [];
+        for (const [key, repository] of repositories) {
+            try {
+                const ref = {
+                    ...identity,
+                    owner: repository.owner,
+                    repo: repository.name
+                };
+                if (!(await client.query.getRepository(ref, signal)).private) {
+                    snapshot.delete(key);
+                    continue;
+                }
+                eligible.push(repository);
+                const definitions = await this.listDefinitions(client.automations, repository, signal);
+                snapshot.set(key, definitions.map(definition => ({
+                    repository,
+                    definition
+                })));
+            } catch (error) {
+                signal.throwIfAborted();
+                if (isCancellationError(error)) {
+                    throw error;
+                }
+                this.logService.warn(`[CloudAutomations] Failed to refresh ${key}`, error);
+                errors.push(error);
+            }
+        }
+        this.rememberRepositories(account.accountName, eligible, signal);
+        transaction(tx => {
+            this.cachedEntries.set([...( snapshot.values())].flat(), tx);
+            this.cachedHistory.set(this.cachedHistory.get().filter(row => ( this.cachedEntries.get().some(entry => sameEntry(row.entry, entry)))), tx);
+            this.state.set(errors.length ? "error" : "ready", tx);
+        });
+        if (errors.length) {
+            throw ( new AggregateError(errors, ( localize(
+                5099,
+                "Some GitHub repositories could not be refreshed. Check the logs for details."
+            ))));
+        }
+    }
+    async listDefinitions(api, repository, signal) {
+        const controller = ( new AbortController());
+        const operationSignal = AbortSignal.any([signal, controller.signal]);
+        try {
+            const definitions = [];
+            for (let page = 1; page <= 10; page++) {
+                operationSignal.throwIfAborted();
+                const response = await api.list(repository, operationSignal, {
+                    ownership: "user",
+                    page,
+                    per_page: 100
+                });
+                const summaries = response.data.automations;
+                for (let offset = 0; offset < summaries.length; offset += 5) {
+                    operationSignal.throwIfAborted();
+                    definitions.push(...(await Promise.all(
+                        summaries.slice(offset, offset + 5).map(summary => api.get(repository, summary.id, operationSignal))
+                    )));
+                }
+                if (!response.nextLink) {
+                    return definitions;
+                }
+            }
+            throw ( new Error(( localize(
+                5100,
+                "This repository has more cloud automations than can be loaded. Its catalogue is incomplete."
+            ))));
+        } finally {
+            controller.abort();
+        }
+    }
+    reset() {
+        this.lifetime.abort(( new CancellationError()));
+        this.clearTargetEligibility();
+        this.lifetime = ( new AbortController());
+        this.clientPromise = undefined;
+        this.clientStore.clear();
+        this.refreshPromise = undefined;
+        this.operations = ( new Sequencer());
+        const account = this.defaultAccountService.currentDefaultAccount;
+        transaction(tx => {
+            this.cachedEntries.set([], tx);
+            this.cachedHistory.set([], tx);
+            this.uncertain.set(false, tx);
+            this.cachedTools.set(undefined, tx);
+            this.state.set(account && !account.enterprise ? "loading" : "unavailable", tx);
+        });
+    }
+    dispose() {
+        this.lifetime.abort(( new CancellationError()));
+        this.clearTargetEligibility();
+        super.dispose();
+        transaction(tx => {
+            this.cachedEntries.set([], tx);
+            this.cachedHistory.set([], tx);
+            this.state.set("unavailable", tx);
+        });
+    }
+    requireAccount() {
+        if (this._store.isDisposed) {
+            throw ( new CancellationError());
+        }
+        const account = this.defaultAccountService.currentDefaultAccount;
+        if (!account || account.enterprise) {
+            throw ( new Error(( localize(
+                5101,
+                "Sign in to GitHub.com with repository access to manage cloud automations."
+            ))));
+        }
+        return account;
+    }
+    async resolveRepository(workspace) {
+        const uri = workspace.scheme === GITHUB_REMOTE_FILE_SCHEME ? workspace : await this.resolveRepositoryUri(workspace);
+        const match = uri?.scheme === GITHUB_REMOTE_FILE_SCHEME && uri.authority === "github" ? /^\/(?<owner>[^/]+)\/(?<name>[^/]+)(?:\/|$)/.exec(uri.path) : undefined;
+        return match?.groups ? {
+            owner: match.groups.owner,
+            name: match.groups.name
+        } : undefined;
+    }
+    readRepositories(account) {
+        const stored = this.storageService.get(this.storageKey(account), StorageScope.PROFILE);
+        const repositories = ( new Map());
+        if (stored !== undefined) {
+            const values = JSON.parse(stored);
+            if (!Array.isArray(values)) {
+                throw ( new Error(( localize(5102, "Invalid stored cloud automation repositories."))));
+            }
+            for (const value of values) {
+                if (!isObject(value) || typeof value.owner !== "string" || !value.owner || value.owner.includes("/") || typeof value.name !== "string" || !value.name || value.name.includes("/")) {
+                    throw ( new Error(( localize(5103, "Invalid stored cloud automation repository."))));
+                }
+                const repository = {
+                    owner: value.owner,
+                    name: value.name
+                };
+                repositories.set(repositoryKey(repository), repository);
+            }
+        }
+        return repositories;
+    }
+    rememberRepositories(account, repositories, signal) {
+        signal.throwIfAborted();
+        const known = this.readRepositories(account);
+        for (const repository of repositories) {
+            known.set(repositoryKey(repository), repository);
+        }
+        this.storageService.store(this.storageKey(account), JSON.stringify([...( known.values())]), StorageScope.PROFILE, StorageTarget.MACHINE);
+    }
+    storageKey(account) {
+        return `${REPOSITORIES_STORAGE_KEY}.${encodeURIComponent(account)}`;
+    }
+};
+GitHubCloudAutomationStore = ( __decorate([( __param(1, IWorkbenchGitHubService)), ( __param(2, IDefaultAccountService)), ( __param(3, IStorageService)), ( __param(4, ILogService)), ( __param(5, ISessionsRecentWorkspacesService))], GitHubCloudAutomationStore));
+function repositoryKey(repository) {
+    return `${repository.owner}/${repository.name}`.toLowerCase();
+}
+function sameEntry(a, b) {
+    return a.definition.id === b.definition.id && repositoryKey(a.repository) === repositoryKey(b.repository);
+}
+
+export { GitHubCloudAutomationStore };

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,5 @@
+
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { CloudSandboxAgentHostContribution } from './cloudSandboxAgentHostContribution.js';
+
+registerWorkbenchContribution2(CloudSandboxAgentHostContribution.ID, CloudSandboxAgentHostContribution, WorkbenchPhase.AfterRestored);

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

@@ -0,0 +1,46 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { DisposableStore, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service";
+import { ICloudSandboxCreatedSession, ICloudSandboxCreateSessionRequest } 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 { 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 { IProgress } from "@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IWorkspaceTrustManagementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service";
+import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
+import { CloudSandboxSessionContribution, ICloudSandboxSessionEnvironment } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/remoteAgentHost/cloudSandboxSessionContribution";
+import { IRemoteAgentHostConnectionCustomizationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/remoteAgentHost/remoteAgentHostConnectionCustomization.service";
+import { IChatEntitlementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service";
+import { IHostService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service";
+import { IAgentHostFilterService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/agentHostFilter/common/agentHostFilter.service";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+import { ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+import { CloudSandboxSessionsProvider } from "./cloudSandboxSessionsProvider.js";
+import { IRemoteAgentHostSessionsProviderConfig } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostSessionsProvider";
+export declare const CLOUD_SANDBOX_CREATION_PROVIDER_ID = "cloud-sandbox-creation";
+export interface ICloudSandboxProvisionedSession extends ICloudSandboxCreatedSession {
+    readonly provider: CloudSandboxSessionsProvider;
+    readonly session: ISession;
+}
+export declare class CloudSandboxAgentHostContribution extends CloudSandboxSessionContribution<CloudSandboxSessionsProvider> {
+    private readonly _remoteService;
+    private readonly _sandboxConnectionCustomizations;
+    private readonly _sessionsProvidersService;
+    private readonly _agentHostFilterService;
+    static readonly ID = "workbench.contrib.cloudSandboxAgentHost";
+    protected get supportsBackgroundConnection(): boolean;
+    private readonly _hostGroupRegistration;
+    constructor(cloudSandboxService: ICloudSandboxAgentHostService, apiService: ICloudSandboxApiService, _remoteService: IRemoteAgentHostService, _sandboxConnectionCustomizations: IRemoteAgentHostConnectionCustomizationService, _sessionsProvidersService: ISessionsProvidersService, _agentHostFilterService: IAgentHostFilterService, configurationService: IConfigurationService, instantiationService: IInstantiationService, chatSessionsService: IChatSessionsService, logService: ILogService, chatEntitlementService: IChatEntitlementService, hostService: IHostService, storageService: IStorageService, workspaceTrustManagementService: IWorkspaceTrustManagementService, localAgentHostService: IAgentHostService);
+    prepareSession(environmentId: string, repoNwo: string, token: CancellationToken): Promise<void>;
+    protected _updateRegistration(): void;
+    protected _ensureProvider(env: ICloudSandboxSessionEnvironment): void;
+    protected _createProvider(env: ICloudSandboxSessionEnvironment, store: DisposableStore): CloudSandboxSessionsProvider;
+    protected _instantiateProvider(config: IRemoteAgentHostSessionsProviderConfig): CloudSandboxSessionsProvider;
+    provisionSession(request: ICloudSandboxCreateSessionRequest, token: CancellationToken, progress?: IProgress<string>): Promise<ICloudSandboxProvisionedSession>;
+    /** Observe repository setup until the caller finishes dispatching the first turn. */
+    trackSessionCreationProgress(environmentId: string, repoNwo: string, progress: IProgress<string>): IDisposable;
+}