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

package/vscode/src/vs/sessions/contrib/automations/browser/providerAutomationService.d.ts

@@ -0,0 +1,62 @@
+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 { 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 { IAutomationDescriptor, IAutomationRun, AutomationRunTrigger } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automation";
+import { AutomationCatalogueState, AutomationMutationGuard, IAutomationRunClaim, ICreateAutomationOptions, IGuardedAutomationUpdateResult, IUpdateAutomationOptions, IUpdateAutomationRunOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationService";
+import { IAutomationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationService.service";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+export declare class ProviderAutomationService extends Disposable implements IAutomationService {
+    private readonly sessionsProvidersService;
+    private readonly logService;
+    readonly _serviceBrand: undefined;
+    private readonly legacyStore;
+    private readonly providersChanged;
+    private readonly migrationSequencer;
+    private readonly migrationRetry;
+    private migrationPromise;
+    private readonly runsForCache;
+    private staleRunRecoveryGeneration;
+    private staleRunRecoveryReason;
+    private readonly recoveredStores;
+    readonly automations: IObservable<readonly IAutomationDescriptor[]>;
+    readonly runs: IObservable<readonly IAutomationRun[]>;
+    readonly catalogueState: IObservable<AutomationCatalogueState>;
+    constructor(initialProvidersSettled: IObservable<boolean>, sessionsProvidersService: ISessionsProvidersService, instantiationService: IInstantiationService, logService: ILogService);
+    getAutomation(id: string): IAutomationDescriptor | undefined;
+    runsFor(automationId: string): IObservable<readonly IAutomationRun[]>;
+    createAutomation(options: ICreateAutomationOptions, mutationGuard?: AutomationMutationGuard): Promise<IAutomationDescriptor>;
+    updateAutomation(id: string, patch: IUpdateAutomationOptions): Promise<IAutomationDescriptor>;
+    updateAutomationIfUnchanged(id: string, patch: IUpdateAutomationOptions, expected: IAutomationDescriptor, mutationGuard?: AutomationMutationGuard): Promise<IGuardedAutomationUpdateResult>;
+    deleteAutomation(id: string, mutationGuard?: AutomationMutationGuard): Promise<void>;
+    recordRunStart(automationId: string, trigger: AutomationRunTrigger, leaderWindowId: number): Promise<IAutomationRunClaim>;
+    updateRun(runId: string, patch: IUpdateAutomationRunOptions): Promise<IAutomationRun | undefined>;
+    deleteRun(runId: string): Promise<void>;
+    getActiveRunFor(automationId: string): IAutomationRun | undefined;
+    isSchedulingOwnedByHost(automationId: string): boolean;
+    canRunAutomation(automationId: string): boolean;
+    canUpdateAutomation(automationId: string): boolean;
+    canDeleteAutomation(automationId: string): boolean;
+    markStaleRunsFailed(reason: string): Promise<void>;
+    startStaleRunRecovery(reason: string): Promise<void>;
+    stopStaleRunRecovery(): void;
+    waitForMigrationForTesting(): Promise<void>;
+    private getProviderStores;
+    private getStores;
+    private getCreationStore;
+    private getTargetStore;
+    private hasTargetChanged;
+    private assertCanTransferStorage;
+    private createActiveRunTransferError;
+    private retargetAutomationStorageIfNeeded;
+    private restoreSourceAfterBlockedTransfer;
+    private findAutomationStore;
+    private requireAutomationStore;
+    private findRunStore;
+    private queueMigration;
+    private recoverStores;
+    private migrateLegacyAutomations;
+    private migrateLegacyAutomation;
+    private completeProviderMigrations;
+    private rollbackAutomationSnapshotIfUnchanged;
+}

package/vscode/src/vs/sessions/contrib/automations/browser/providerAutomationService.js

@@ -0,0 +1,493 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Sequencer, disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { isCancellationError, CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Disposable, MutableDisposable } 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 { 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 { combineAutomationCatalogueStates, serializeAutomationEditableState, isAutomationActiveRunError } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationService';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { AutomationService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/automations/browser/automationService';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+
+const MAX_AUTOMATION_TRANSFER_ATTEMPTS = 3;
+const AUTOMATION_MIGRATION_RETRY_DELAY_MS = 30_000;
+let ProviderAutomationService = class ProviderAutomationService extends Disposable {
+    constructor(
+        initialProvidersSettled,
+        sessionsProvidersService,
+        instantiationService,
+        logService
+    ) {
+        super();
+        this.sessionsProvidersService = sessionsProvidersService;
+        this.logService = logService;
+        this.migrationSequencer = ( new Sequencer());
+        this.migrationRetry = this._register(( new MutableDisposable()));
+        this.migrationPromise = Promise.resolve();
+        this.runsForCache = ( new Map());
+        this.staleRunRecoveryGeneration = 0;
+        this.recoveredStores = ( new Set());
+        this.legacyStore = this._register(instantiationService.createInstance(AutomationService));
+        this.providersChanged = observableSignalFromEvent(this, sessionsProvidersService.onDidChangeProviders);
+        this.catalogueState = derived(this, reader => {
+            this.providersChanged.read(reader);
+            const states = this.getStores().map(entry => entry.store.catalogueState.read(reader));
+            if (!initialProvidersSettled.read(reader)) {
+                states.push("loading");
+            }
+            return combineAutomationCatalogueStates(states);
+        });
+        this.automations = derived(this, reader => {
+            this.providersChanged.read(reader);
+            return distinctById(
+                this.getStores().flatMap(entry => [...entry.store.automations.read(reader)])
+            ).sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+        });
+        this.runs = derived(this, reader => {
+            this.providersChanged.read(reader);
+            return distinctById(this.getStores().flatMap(entry => [...entry.store.runs.read(reader)])).sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+        });
+        this._register(sessionsProvidersService.onDidChangeProviders(event => {
+            for (const provider of event.removed) {
+                if (provider.automations) {
+                    this.recoveredStores.delete(provider.automations);
+                }
+            }
+            if (( event.added.some(provider => provider.automations))) {
+                this.queueMigration();
+            }
+        }));
+        this.queueMigration();
+    }
+    getAutomation(id) {
+        return this.findAutomationStore(id)?.store.getAutomation(id);
+    }
+    runsFor(automationId) {
+        let result = this.runsForCache.get(automationId);
+        if (!result) {
+            result = derived(
+                this,
+                reader => this.runs.read(reader).filter(run => run.automationId === automationId)
+            );
+            this.runsForCache.set(automationId, result);
+        }
+        return result;
+    }
+    createAutomation(options, mutationGuard) {
+        return this.getCreationStore(options).createAutomation(options, mutationGuard);
+    }
+    async updateAutomation(id, patch) {
+        const source = this.requireAutomationStore(id);
+        let previous = source.getAutomation(id);
+        while (previous) {
+            const targetChanged = this.hasTargetChanged(previous, patch.target);
+            this.assertCanTransferStorage(source, id, patch.target, targetChanged);
+            const result = await source.updateAutomationIfUnchanged(id, patch, previous);
+            if (result.kind === "conflict") {
+                previous = result.current;
+                continue;
+            }
+            await this.retargetAutomationStorageIfNeeded(source, result.automation, previous, targetChanged);
+            return result.automation;
+        }
+        throw ( new Error(`Automation '${id}' does not exist.`));
+    }
+    async updateAutomationIfUnchanged(id, patch, expected, mutationGuard) {
+        const source = this.requireAutomationStore(id);
+        const previous = source.getAutomation(id);
+        if (!previous) {
+            return {
+                kind: "conflict",
+                current: undefined
+            };
+        }
+        if (serializeAutomationEditableState(previous) !== serializeAutomationEditableState(expected)) {
+            return {
+                kind: "conflict",
+                current: previous
+            };
+        }
+        const targetChanged = this.hasTargetChanged(previous, patch.target);
+        this.assertCanTransferStorage(source, id, patch.target, targetChanged);
+        const result = await source.updateAutomationIfUnchanged(id, patch, expected, mutationGuard);
+        if (result.kind === "updated") {
+            await this.retargetAutomationStorageIfNeeded(source, result.automation, previous, targetChanged);
+        }
+        return result;
+    }
+    async deleteAutomation(id, mutationGuard) {
+        await this.requireAutomationStore(id).deleteAutomation(id, mutationGuard);
+        this.runsForCache.delete(id);
+    }
+    recordRunStart(automationId, trigger, leaderWindowId) {
+        return this.requireAutomationStore(automationId).recordRunStart(automationId, trigger, leaderWindowId);
+    }
+    updateRun(runId, patch) {
+        const store = this.findRunStore(runId);
+        return store ? store.updateRun(runId, patch) : Promise.resolve(undefined);
+    }
+    deleteRun(runId) {
+        const store = this.findRunStore(runId);
+        return store ? store.deleteRun(runId) : Promise.resolve();
+    }
+    getActiveRunFor(automationId) {
+        return this.findAutomationStore(automationId)?.store.getActiveRunFor(automationId);
+    }
+    isSchedulingOwnedByHost(automationId) {
+        return this.findAutomationStore(automationId)?.store.isSchedulingOwnedByHost?.(automationId) === true;
+    }
+    canRunAutomation(automationId) {
+        const entry = this.findAutomationStore(automationId);
+        return entry?.store.canRunAutomation?.(automationId) ?? entry !== undefined;
+    }
+    canUpdateAutomation(automationId) {
+        const entry = this.findAutomationStore(automationId);
+        return entry?.store.canUpdateAutomation?.(automationId) ?? entry !== undefined;
+    }
+    canDeleteAutomation(automationId) {
+        const entry = this.findAutomationStore(automationId);
+        return entry?.store.canDeleteAutomation?.(automationId) ?? entry !== undefined;
+    }
+    async markStaleRunsFailed(reason) {
+        await this.migrationPromise;
+        const stores = this.getStores();
+        const results = await Promise.allSettled(stores.map(entry => entry.store.markStaleRunsFailed(reason)));
+        for (let index = 0; index < results.length; index++) {
+            const result = results[index];
+            if (result.status === "rejected") {
+                const providerId = stores[index].providerId ?? "legacy";
+                this.logService.error(
+                    `[ProviderAutomationService] Failed to recover stale Automation runs for '${providerId}'.`,
+                    result.reason
+                );
+            }
+        }
+    }
+    async startStaleRunRecovery(reason) {
+        const generation = ++this.staleRunRecoveryGeneration;
+        this.staleRunRecoveryReason = reason;
+        this.recoveredStores.clear();
+        const stores = this.getStores();
+        this.migrationPromise = this.migrationSequencer.queue(() => this.recoverStores(stores, reason, generation)).catch(error => {
+            this.logService.error(
+                "[ProviderAutomationService] Failed to start stale Automation run recovery.",
+                error
+            );
+        });
+        await this.migrationPromise;
+    }
+    stopStaleRunRecovery() {
+        this.staleRunRecoveryGeneration++;
+        this.staleRunRecoveryReason = undefined;
+        this.recoveredStores.clear();
+    }
+    waitForMigrationForTesting() {
+        return this.migrationPromise;
+    }
+    getProviderStores() {
+        return this.sessionsProvidersService.getProviders().filter(provider => provider.automations).map(provider => ({
+            providerId: provider.id,
+            store: provider.automations
+        }));
+    }
+    getStores() {
+        return [...this.getProviderStores(), {
+            providerId: undefined,
+            store: this.legacyStore
+        }];
+    }
+    getCreationStore(options) {
+        return this.getTargetStore(options.target.providerId);
+    }
+    getTargetStore(providerId) {
+        if (providerId) {
+            const providerStore = this.sessionsProvidersService.getProvider(providerId)?.automations;
+            if (providerStore) {
+                return providerStore;
+            }
+        }
+        return this.legacyStore;
+    }
+    hasTargetChanged(current, target) {
+        return !!target && serializeAutomationEditableState(current) !== serializeAutomationEditableState({
+            ...current,
+            target
+        });
+    }
+    assertCanTransferStorage(source, automationId, target, targetChanged) {
+        if (!targetChanged || !target || source === this.getTargetStore(target.providerId) || !source.getActiveRunFor(automationId)) {
+            return;
+        }
+        throw this.createActiveRunTransferError();
+    }
+    createActiveRunTransferError() {
+        return (new Error(localize(
+            3385,
+            "Wait for the active run to finish before changing this automation's agent."
+        )));
+    }
+    async retargetAutomationStorageIfNeeded(sourceStore, initialAutomation, previousAutomation, targetChanged) {
+        let snapshot = {
+            automation: initialAutomation,
+            runs: sourceStore.runsFor(initialAutomation.id).get()
+        };
+        for (let attempt = 0; attempt < MAX_AUTOMATION_TRANSFER_ATTEMPTS; attempt++) {
+            const destinationStore = this.getTargetStore(snapshot.automation.target.providerId);
+            if (sourceStore === destinationStore) {
+                return;
+            }
+            if (sourceStore.getActiveRunFor(snapshot.automation.id)) {
+                if (!targetChanged) {
+                    return;
+                }
+                await this.restoreSourceAfterBlockedTransfer(sourceStore, initialAutomation, previousAutomation);
+                throw this.createActiveRunTransferError();
+            }
+            try {
+                await destinationStore.upsertAutomationSnapshot(snapshot);
+            } catch (error) {
+                if (!isAutomationActiveRunError(error)) {
+                    throw error;
+                }
+                if (!targetChanged) {
+                    return;
+                }
+                await this.restoreSourceAfterBlockedTransfer(sourceStore, initialAutomation, previousAutomation);
+                throw this.createActiveRunTransferError();
+            }
+            if (destinationStore.preservesImportedRunHistory === false) {
+                return;
+            }
+            const sourceRemoval = await sourceStore.removeAutomationSnapshotIfUnchanged(snapshot);
+            switch (sourceRemoval.kind) {
+            case "removed":
+                await destinationStore.acknowledgeAutomationSnapshotImported?.(snapshot);
+                return;
+            case "missing":
+                await this.rollbackAutomationSnapshotIfUnchanged(destinationStore, snapshot);
+                return;
+            case "conflict":
+                if (!(await this.rollbackAutomationSnapshotIfUnchanged(destinationStore, snapshot))) {
+                    return;
+                }
+                snapshot = sourceRemoval.current;
+                break;
+            }
+        }
+        this.logService.warn(
+            `[ProviderAutomationService] Automation '${snapshot.automation.id}' kept changing while transferring storage ownership; leaving the source copy in place.`
+        );
+    }
+    async restoreSourceAfterBlockedTransfer(sourceStore, expected, previous) {
+        try {
+            const result = await sourceStore.updateAutomationIfUnchanged(expected.id, {
+                name: previous.name,
+                prompt: previous.prompt,
+                schedule: previous.schedule,
+                target: previous.target,
+                ...(previous.sessionTemplate ? {
+                    sessionTemplate: previous.sessionTemplate
+                } : {
+                    modelId: previous.modelId ?? null,
+                    mode: previous.mode ?? null,
+                    permissionLevel: previous.permissionLevel ?? null
+                }),
+                enabled: previous.enabled
+            }, expected);
+            if (result.kind === "conflict") {
+                this.logService.warn(
+                    `[ProviderAutomationService] Automation '${expected.id}' changed while its active run blocked storage transfer; the latest source state was preserved.`
+                );
+            }
+        } catch (error) {
+            this.logService.error(
+                `[ProviderAutomationService] Failed to restore the source state after an active run blocked storage transfer for '${expected.id}'.`,
+                error
+            );
+        }
+    }
+    findAutomationStore(id) {
+        return this.getStores().find(entry => !!entry.store.getAutomation(id));
+    }
+    requireAutomationStore(id) {
+        const entry = this.findAutomationStore(id);
+        if (!entry) {
+            throw ( new Error(`Automation '${id}' does not exist.`));
+        }
+        return entry.store;
+    }
+    findRunStore(runId) {
+        return this.getStores().find(entry => ( entry.store.runs.get().some(run => run.id === runId)))?.store;
+    }
+    queueMigration() {
+        this.migrationRetry.clear();
+        const migration = this.migrationSequencer.queue(async () => {
+            const initialRecoveryReason = this.staleRunRecoveryReason;
+            if (initialRecoveryReason) {
+                await this.recoverStores(this.getStores(), initialRecoveryReason, this.staleRunRecoveryGeneration);
+            }
+            await this.migrateLegacyAutomations();
+            await this.completeProviderMigrations();
+            const finalRecoveryReason = this.staleRunRecoveryReason;
+            if (finalRecoveryReason) {
+                await this.recoverStores(this.getStores(), finalRecoveryReason, this.staleRunRecoveryGeneration);
+            }
+        });
+        this.migrationPromise = migration;
+        void migration.then(() => this.migrationRetry.clear(), error => {
+            if (this._store.isDisposed || isCancellationError(error)) {
+                return;
+            }
+            if (isAutomationActiveRunError(error)) {
+                this.logService.info(
+                    `[ProviderAutomationService] Automation migration deferred while a run is active; retrying in ${AUTOMATION_MIGRATION_RETRY_DELAY_MS}ms.`
+                );
+            } else {
+                this.logService.error(
+                    `[ProviderAutomationService] Failed to migrate legacy Automations; retrying in ${AUTOMATION_MIGRATION_RETRY_DELAY_MS}ms.`,
+                    error
+                );
+            }
+            this.migrationRetry.value = disposableTimeout(() => this.queueMigration(), AUTOMATION_MIGRATION_RETRY_DELAY_MS);
+        });
+    }
+    async recoverStores(entries, reason, generation) {
+        for (const entry of entries) {
+            if (generation !== this.staleRunRecoveryGeneration || this.staleRunRecoveryReason !== reason) {
+                return;
+            }
+            if (( this.recoveredStores.has(entry.store))) {
+                continue;
+            }
+            try {
+                await entry.store.markStaleRunsFailed(reason);
+                if (generation === this.staleRunRecoveryGeneration && this.staleRunRecoveryReason === reason) {
+                    this.recoveredStores.add(entry.store);
+                }
+            } catch (error) {
+                const providerId = entry.providerId ?? "legacy";
+                this.logService.error(
+                    `[ProviderAutomationService] Failed to recover stale Automation runs for '${providerId}'.`,
+                    error
+                );
+            }
+        }
+    }
+    async migrateLegacyAutomations() {
+        if (this.legacyStore.canCompleteMigration() === false) {
+            throw ( new Error("Legacy Automation storage cannot be migrated safely by this version."));
+        }
+        const failures = [];
+        for (const automation of [...this.legacyStore.automations.get()]) {
+            try {
+                await this.migrateLegacyAutomation(automation);
+            } catch (error) {
+                if (isCancellationError(error) || this._store.isDisposed) {
+                    throw ( new CancellationError());
+                }
+                if (isAutomationActiveRunError(error)) {
+                    this.logService.info(
+                        `[ProviderAutomationService] Deferred migration for Automation '${automation.id}' while a run is active.`
+                    );
+                } else {
+                    this.logService.error(
+                        `[ProviderAutomationService] Failed to migrate Automation '${automation.id}'.`,
+                        error
+                    );
+                }
+                failures.push(error instanceof Error ? error : ( new Error(String(error))));
+            }
+        }
+        if (failures.length > 0) {
+            throw ( new AggregateError(failures, `Failed to migrate ${failures.length} Automation snapshot(s).`));
+        }
+    }
+    async migrateLegacyAutomation(initialAutomation) {
+        let snapshot = {
+            automation: initialAutomation,
+            runs: this.legacyStore.runsFor(initialAutomation.id).get()
+        };
+        for (let attempt = 0; attempt < MAX_AUTOMATION_TRANSFER_ATTEMPTS; attempt++) {
+            const providerId = snapshot.automation.target.providerId;
+            if (!providerId) {
+                return;
+            }
+            const providerStore = this.sessionsProvidersService.getProvider(providerId)?.automations;
+            if (!providerStore) {
+                return;
+            }
+            const importResult = await providerStore.importAutomationSnapshot(snapshot);
+            if (importResult.kind === "conflict") {
+                this.logService.warn(
+                    `[ProviderAutomationService] Automation '${snapshot.automation.id}' conflicts with the destination provider store; leaving the legacy copy in place.`
+                );
+                return;
+            }
+            this.recoveredStores.delete(providerStore);
+            if (providerStore.preservesImportedRunHistory === false) {
+                return;
+            }
+            const sourceRemoval = await this.legacyStore.removeAutomationSnapshotIfUnchanged(snapshot);
+            switch (sourceRemoval.kind) {
+            case "removed":
+                await providerStore.acknowledgeAutomationSnapshotImported?.(snapshot);
+                return;
+            case "missing":
+                if (importResult.kind === "inserted") {
+                    await this.rollbackAutomationSnapshotIfUnchanged(providerStore, snapshot);
+                }
+                return;
+            case "conflict":
+                if (importResult.kind === "inserted" && !(await this.rollbackAutomationSnapshotIfUnchanged(providerStore, snapshot))) {
+                    return;
+                }
+                snapshot = sourceRemoval.current;
+                break;
+            }
+        }
+        this.logService.warn(
+            `[ProviderAutomationService] Automation '${snapshot.automation.id}' kept changing during legacy migration; leaving it in legacy storage.`
+        );
+    }
+    async completeProviderMigrations() {
+        const stores = [...( new Set(this.getStores().map(entry => entry.store)))];
+        for (const store of stores) {
+            await store.completeMigration?.();
+        }
+    }
+    async rollbackAutomationSnapshotIfUnchanged(store, snapshot) {
+        const result = await store.removeAutomationSnapshotIfUnchanged(snapshot);
+        switch (result.kind) {
+        case "removed":
+            return true;
+        case "conflict":
+            this.logService.warn(
+                `[ProviderAutomationService] Automation '${snapshot.automation.id}' changed in the destination store during rollback; leaving both copies in place.`
+            );
+            return false;
+        case "missing":
+            this.logService.warn(
+                `[ProviderAutomationService] Automation '${snapshot.automation.id}' was deleted from the destination store during rollback; leaving the source copy in place.`
+            );
+            return false;
+        }
+    }
+};
+ProviderAutomationService = ( __decorate([( __param(1, ISessionsProvidersService)), ( __param(2, IInstantiationService)), ( __param(3, ILogService))], ProviderAutomationService));
+function distinctById(items) {
+    const result = [];
+    const seen = ( new Set());
+    for (const item of items) {
+        if (!( seen.has(item.id))) {
+            seen.add(item.id);
+            result.push(item);
+        }
+    }
+    return result;
+}
+
+export { ProviderAutomationService };

package/vscode/src/vs/sessions/contrib/automations/common/isolationGroupModel.d.ts

@@ -0,0 +1,38 @@
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+export declare function normalizeAutomationBranchNames(names: Iterable<string | undefined>): readonly string[];
+export interface IAutomationIsolationFormState {
+    isQuickChat: boolean;
+    folderUri: URI | undefined;
+    isolationMode: string | undefined;
+    branch: string | undefined;
+}
+/**
+ * Keeps explicit Worktree branch intent separate from the repository's live HEAD.
+ */
+export declare class AutomationIsolationModel {
+    private readonly _state;
+    private _headBranch;
+    private _selectedBranch;
+    private _supportsWorktreeConfiguration;
+    private readonly _isQuickChat;
+    readonly isQuickChatObs: IObservable<boolean>;
+    private readonly _folderUri;
+    readonly folderUriObs: IObservable<URI | undefined>;
+    constructor(_state: IAutomationIsolationFormState);
+    get isQuickChat(): boolean;
+    get folderUri(): URI | undefined;
+    get isolationMode(): string;
+    get selectedBranch(): string | undefined;
+    get headBranch(): string | undefined;
+    get displayBranch(): string | undefined;
+    get persistedBranch(): string | undefined;
+    get supportsWorktreeConfiguration(): boolean;
+    get branchPickerAvailable(): boolean;
+    setSupportsWorktreeConfiguration(supported: boolean): void;
+    selectIsolationMode(mode: "workspace" | "worktree"): boolean;
+    setQuickChat(isQuickChat: boolean, workspaceFolderUri?: URI): void;
+    setWorkspace(folderUri: URI | undefined): boolean;
+    setHeadBranch(branch: string | undefined): void;
+    selectBranch(branch: string): void;
+}