@codingame/monaco-vscode-workbench-service-override 37.3.3 → 37.3.4

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/agentHostPermissionPickerDelegate.d.ts

@@ -0,0 +1,84 @@
+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 { IAgentHostConnectionsService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostConnectionsService.service";
+import { IAgentHostEnablementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostEnablementService.service";
+import { SessionConfigPropertySchema } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands";
+import { ChatConfiguration, ChatPermissionLevel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
+import { IPermissionLevelMeta, IPermissionPickerDelegate } from "@codingame/monaco-vscode-katex-common/vscode/vs/sessions/contrib/providers/copilotChatSessions/browser/permissionPicker";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+import { IActiveSession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IChatPhoneInputPresenter } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatPhoneInputPresenter.service";
+import { isWellKnownAutoApproveSchema, isWellKnownModeSchema } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostModePickerPresentation";
+export { isWellKnownAutoApproveSchema, isWellKnownModeSchema };
+/**
+ * {@link IPermissionPickerDelegate} backed by the active session's AHP
+ * `autoApprove` config property.
+ *
+ * - `currentPermissionLevel` derives from the active session's
+ *   `provider.getSessionConfig(...).values.autoApprove`, recomputed when the
+ *   active session changes or when any agent-host provider fires
+ *   `onDidChangeSessionConfig`.
+ * - `setPermissionLevel(level)` calls `provider.setSessionConfigValue(sessionId,
+ *   'autoApprove', level)` for the active session's provider.
+ * - `isApplicable` is `true` only when the active session's `autoApprove`
+ *   schema matches the well-known shape, so the picker hides itself for
+ *   non-conforming agents (which fall back to the generic per-property
+ *   picker) and when no agent-host session is active.
+ */
+export declare class AgentHostPermissionPickerDelegate extends Disposable implements IPermissionPickerDelegate {
+    private readonly _session;
+    private readonly _sessionsProvidersService;
+    private readonly _configurationService;
+    private readonly _connectionsService;
+    private readonly _logService;
+    /** Fires every time any agent-host provider's session config changes. */
+    private readonly _configChangedSignal;
+    private readonly _providerSubscriptions;
+    private _sandboxConnection;
+    private readonly _hostOperatingSystem;
+    private _hostOperatingSystemRequest;
+    readonly currentPermissionLevel: IObservable<ChatPermissionLevel>;
+    readonly isApplicable: IObservable<boolean>;
+    readonly isModePickerCombined: IObservable<boolean>;
+    readonly isResolving: IObservable<boolean>;
+    readonly managedSandboxEnforced: IObservable<boolean>;
+    readonly managedSandboxAllowsBypass: IObservable<boolean>;
+    readonly sandboxEnabled: IObservable<boolean | undefined>;
+    readonly sandboxToggleSettingId: IObservable<string | undefined>;
+    readonly sandboxToggleConfigurationKeys: string[];
+    readonly getSandboxToggleProvider: () => string | undefined;
+    readonly isSandboxToggleApplicable: () => boolean;
+    readonly getSandboxToggleSettingId: () => string | undefined;
+    get availableLevels(): readonly ChatPermissionLevel[];
+    /** Agent-host sessions seed their default approval level from this setting. */
+    readonly defaultSettingKey = ChatConfiguration.DefaultConfiguration;
+    getPermissionLevelMeta(level: ChatPermissionLevel, meta: IPermissionLevelMeta): IPermissionLevelMeta;
+    constructor(_session: IObservable<IActiveSession | undefined>, _sessionsProvidersService: ISessionsProvidersService, _configurationService: IConfigurationService, agentHostEnablementService: IAgentHostEnablementService, phoneInputPresenter: IChatPhoneInputPresenter, _connectionsService: IAgentHostConnectionsService, _logService: ILogService);
+    private _resolveHostOperatingSystem;
+    getSandboxToggle(): import("@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionList").IActionListItemInlineToggle | undefined;
+    setSandboxEnabled(enabled: boolean): void;
+    setPermissionLevel(level: ChatPermissionLevel): Promise<void>;
+    getPermissionLevelHover(level: ChatPermissionLevel, _meta: IPermissionLevelMeta): string;
+    private _readLevel;
+    private _readIsWellKnown;
+    private _getProvider;
+    private _watchProviders;
+}
+export declare function isWellKnownModeValue(schema: SessionConfigPropertySchema, value: string): boolean;
+/**
+ * Returns `true` when a `permissionMode` session-config property uses the
+ * Claude SDK's well-known permission-mode value set and includes `default`.
+ */
+export declare function isWellKnownClaudePermissionModeSchema(schema: SessionConfigPropertySchema): boolean;
+/**
+ * Returns `true` when a `codex.permissionsPreset` session-config property uses
+ * the Codex permissions-preset value set and includes `default`.
+ *
+ * Codex collapses its three security axes (sandbox × approval policy ×
+ * approvals reviewer) into a single user-facing preset; this guard lets the
+ * dedicated {@link AgentHostCodexApprovalsPicker} claim the property while the
+ * generic per-property picker stands down.
+ */
+export declare function isWellKnownCodexApprovalsSchema(schema: SessionConfigPropertySchema): boolean;

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/agentHostPermissionPickerDelegate.js

@@ -0,0 +1,328 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Disposable, DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { createAgentHostSandboxToggle } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/browser/agentHostSandboxToggle';
+import { AgentHostSdkSandboxEnabledSettingId, AgentHostSdkSandboxWindowsEnabledSettingId, getAgentHostCopilotSandboxSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService';
+import { IAgentHostConnectionsService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostConnectionsService.service';
+import { getAgentHostOperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostOperatingSystem';
+import { IAgentHostEnablementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostEnablementService.service';
+import { AgentHostCustomTerminalToolEnabledSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/copilotCliConfig';
+import { SessionConfigKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/sessionConfigKeys';
+import { narrowClaudePermissionMode } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/claudeSessionConfigKeys';
+import { narrowCodexPermissionsPreset } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/codexSessionConfigKeys';
+import { ChatPermissionLevel, ChatConfiguration, isChatPermissionLevel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { isAgentHostProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { isAssistedPermissionsEnabled, isPermissionLevelVisible } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/agentHostConfigPolicy';
+import { AgentSandboxSettingId, isAgentSandboxEnabledValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/settings';
+import { CopilotCLISessionType } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/agentHost/browser/baseAgentHostSessionsProvider';
+import { IChatPhoneInputPresenter } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatPhoneInputPresenter.service';
+import { shouldCombineModeAndPermissions, isWellKnownAutoApproveSchema } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostModePickerPresentation';
+export { isWellKnownAutoApproveSchema, isWellKnownModeSchema } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostModePickerPresentation';
+import { observableSignal } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignal';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+const REQUIRED_PERMISSION_MODE_VALUE = "default";
+const REQUIRED_CODEX_APPROVALS_VALUE = "default";
+let AgentHostPermissionPickerDelegate = class AgentHostPermissionPickerDelegate extends Disposable {
+    get availableLevels() {
+        const session = this._session.get();
+        if (!session) {
+            return [ChatPermissionLevel.Default];
+        }
+        const provider = this._getProvider(session.providerId);
+        const schema = provider?.getSessionConfig(session.sessionId)?.schema.properties[SessionConfigKey.AutoApprove];
+        const values = schema?.type === "string" && Array.isArray(schema.enum) ? schema.enum : [];
+        const assistedPermissionsEnabled = isAssistedPermissionsEnabled(this._configurationService);
+        return [
+            ChatPermissionLevel.Default,
+            ChatPermissionLevel.Assisted,
+            ChatPermissionLevel.AutoApprove
+        ].filter(
+            level => values.includes(level) && isPermissionLevelVisible(level, assistedPermissionsEnabled)
+        );
+    }
+    getPermissionLevelMeta(level, meta) {
+        switch (level) {
+        case ChatPermissionLevel.Default:
+            return {
+                ...meta,
+                label: ( localize(4199, "Manual permissions")),
+                detail: ( localize(4200, "Asks when approval settings don't apply")),
+                icon: Codicon.key
+            };
+        case ChatPermissionLevel.Assisted:
+            return {
+                ...meta,
+                detail: ( localize(4201, "Evaluates risk before running tools"))
+            };
+        case ChatPermissionLevel.AutoApprove:
+            return {
+                ...meta,
+                detail: ( localize(4202, "Runs tool calls without asking"))
+            };
+        case ChatPermissionLevel.Autopilot:
+            return meta;
+        }
+    }
+    constructor(
+        _session,
+        _sessionsProvidersService,
+        _configurationService,
+        agentHostEnablementService,
+        phoneInputPresenter,
+        _connectionsService,
+        _logService
+    ) {
+        super();
+        this._session = _session;
+        this._sessionsProvidersService = _sessionsProvidersService;
+        this._configurationService = _configurationService;
+        this._connectionsService = _connectionsService;
+        this._logService = _logService;
+        this._configChangedSignal = observableSignal("agentHostPermissionPicker.configChanged");
+        this._providerSubscriptions = this._register(( new DisposableMap()));
+        this._hostOperatingSystem = observableValue(this, undefined);
+        this.sandboxToggleConfigurationKeys = [
+            AgentHostCustomTerminalToolEnabledSettingId,
+            AgentHostSdkSandboxEnabledSettingId,
+            AgentHostSdkSandboxWindowsEnabledSettingId,
+            AgentSandboxSettingId.AgentSandboxEnabled,
+            AgentSandboxSettingId.AgentSandboxWindowsEnabled
+        ];
+        this.getSandboxToggleProvider = () => this._session.get()?.sessionType;
+        this.isSandboxToggleApplicable = () => {
+            const session = this._session.get();
+            return session?.sessionType === CopilotCLISessionType.id && !!this._getProvider(session.providerId)?.getSessionConfig(session.sessionId)?.schema.properties[SessionConfigKey.SandboxEnabled];
+        };
+        this.getSandboxToggleSettingId = () => this.sandboxToggleSettingId.get();
+        this.defaultSettingKey = ChatConfiguration.DefaultConfiguration;
+        this.managedSandboxEnforced = agentHostEnablementService.managedSandboxEnforced;
+        this.managedSandboxAllowsBypass = agentHostEnablementService.managedSandboxAllowsBypass;
+        this._watchProviders(this._sessionsProvidersService.getProviders());
+        this._register(this._sessionsProvidersService.onDidChangeProviders(e => {
+            for (const provider of e.removed) {
+                this._providerSubscriptions.deleteAndDispose(provider.id);
+            }
+            this._watchProviders(e.added);
+            this._configChangedSignal.trigger(undefined);
+        }));
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(ChatConfiguration.ExperimentalModePermissionsPicker)) {
+                this._configChangedSignal.trigger(undefined);
+            }
+        }));
+        this.currentPermissionLevel = derived(this, reader => this._readLevel(reader));
+        this.sandboxEnabled = derived(this, reader => {
+            this._configChangedSignal.read(reader);
+            const session = this._session.read(reader);
+            const value = session && this._getProvider(session.providerId)?.getSessionConfig(session.sessionId)?.values[SessionConfigKey.SandboxEnabled];
+            return value === "on" ? true : value === "off" ? false : undefined;
+        });
+        this.sandboxToggleSettingId = derived(this, reader => {
+            this._configChangedSignal.read(reader);
+            this._session.read(reader);
+            const os = this._hostOperatingSystem.read(reader);
+            return this.isSandboxToggleApplicable() && os !== undefined ? getAgentHostCopilotSandboxSettingId(os === OperatingSystem.Windows) : undefined;
+        });
+        this.isModePickerCombined = derived(this, reader => {
+            this._configChangedSignal.read(reader);
+            const session = this._session.read(reader);
+            const config = session ? this._getProvider(session.providerId)?.getSessionConfig(session.sessionId) : undefined;
+            return !phoneInputPresenter.enabled.read(reader) && shouldCombineModeAndPermissions(
+                this._configurationService.getValue(ChatConfiguration.ExperimentalModePermissionsPicker) === true,
+                session?.sessionType === CopilotCLISessionType.id,
+                config?.schema.properties[SessionConfigKey.Mode],
+                config?.schema.properties[SessionConfigKey.AutoApprove]
+            );
+        });
+        this.isApplicable = derived(
+            this,
+            reader => this._readIsWellKnown(reader) && !this.isModePickerCombined.read(reader)
+        );
+        this.isResolving = derived(this, reader => {
+            this._configChangedSignal.read(reader);
+            const session = this._session.read(reader);
+            if (!session) {
+                return false;
+            }
+            const provider = this._getProvider(session.providerId);
+            return provider?.isSessionConfigResolving(session.sessionId).read(reader) ?? false;
+        });
+        this._register(this._connectionsService.onDidChangeSessionResolution(async () => {
+            const connection = this._sandboxConnection;
+            const request = this._hostOperatingSystemRequest;
+            await request;
+            if (!this._store.isDisposed && connection && request && this._sandboxConnection === connection && this._hostOperatingSystemRequest === request && this._hostOperatingSystem.get() === undefined) {
+                this._hostOperatingSystemRequest = this._resolveHostOperatingSystem(connection);
+            }
+        }));
+        const connectionsChanged = observableSignalFromEvent(this, this._connectionsService.onDidChangeSessionResolution);
+        this._register(autorun(reader => {
+            connectionsChanged.read(reader);
+            this._configChangedSignal.read(reader);
+            const session = this._session.read(reader);
+            const connection = session && this.isSandboxToggleApplicable() ? this._connectionsService.resolveSessionResource(session.resource)?.connection : undefined;
+            if (connection === this._sandboxConnection) {
+                return;
+            }
+            this._sandboxConnection = connection;
+            this._hostOperatingSystem.set(undefined, undefined);
+            this._hostOperatingSystemRequest = connection ? this._resolveHostOperatingSystem(connection) : undefined;
+        }));
+    }
+    async _resolveHostOperatingSystem(connection) {
+        try {
+            const os = await getAgentHostOperatingSystem(connection);
+            if (!this._store.isDisposed && this._sandboxConnection === connection) {
+                this._hostOperatingSystem.set(os, undefined);
+            }
+        } catch (error) {
+            this._logService.error("Failed to resolve agent host OS for the sandbox picker", error);
+        }
+    }
+    getSandboxToggle() {
+        if (!this.isSandboxToggleApplicable() || this.getSandboxToggleSettingId() === undefined) {
+            return undefined;
+        }
+        return createAgentHostSandboxToggle(() => {
+            const settingId = this.getSandboxToggleSettingId();
+            return {
+                provider: this.getSandboxToggleProvider(),
+                sessionEnabled: this.sandboxEnabled.get(),
+                globalEnabled: settingId !== undefined && isAgentSandboxEnabledValue(this._configurationService.getValue(settingId)),
+                managedEnabled: this.managedSandboxEnforced.get(),
+                allowsBypass: this.managedSandboxAllowsBypass.get()
+            };
+        }, enabled => this.setSandboxEnabled(enabled));
+    }
+    setSandboxEnabled(enabled) {
+        const session = this._session.get();
+        const provider = session && this._getProvider(session.providerId);
+        if (!session || !provider || !this.isSandboxToggleApplicable()) {
+            throw ( new Error("Sandbox configuration is unavailable for this session"));
+        }
+        const operation = provider.setSessionConfigValue(session.sessionId, SessionConfigKey.SandboxEnabled, enabled ? "on" : "off");
+        provider.trackSessionConfigOperation(session.sessionId, operation);
+        void operation.catch(onUnexpectedError);
+    }
+    async setPermissionLevel(level) {
+        if (!isPermissionLevelVisible(level, isAssistedPermissionsEnabled(this._configurationService))) {
+            return;
+        }
+        const session = this._session.get();
+        if (!session) {
+            return;
+        }
+        const provider = this._getProvider(session.providerId);
+        if (!provider) {
+            return;
+        }
+        if (provider.isSessionConfigResolving(session.sessionId).get()) {
+            return;
+        }
+        if (!this.availableLevels.includes(level)) {
+            return;
+        }
+        const operation = provider.setSessionConfigValue(session.sessionId, SessionConfigKey.AutoApprove, level);
+        provider.trackSessionConfigOperation(session.sessionId, operation);
+        await operation.catch(onUnexpectedError);
+    }
+    getPermissionLevelHover(level, _meta) {
+        switch (level) {
+        case ChatPermissionLevel.Default:
+            return localize(
+                4203,
+                "Copilot asks before running tools unless your configured settings allow the tool."
+            );
+        case ChatPermissionLevel.AutoApprove:
+            return localize(4204, "Copilot runs all tools without asking for approval.");
+        case ChatPermissionLevel.Assisted:
+            return localize(
+                4205,
+                "An LLM judge evaluates each tool call. Tools it doesn't approve require your approval."
+            );
+        case ChatPermissionLevel.Autopilot:
+            return localize(
+                4206,
+                "Copilot runs tools without asking for approval and continues until the task is done."
+            );
+        }
+    }
+    _readLevel(reader) {
+        this._configChangedSignal.read(reader);
+        const session = this._session.read(reader);
+        if (!session) {
+            return ChatPermissionLevel.Default;
+        }
+        const provider = this._getProvider(session.providerId);
+        if (!provider) {
+            return ChatPermissionLevel.Default;
+        }
+        const value = provider.getSessionConfig(session.sessionId)?.values[SessionConfigKey.AutoApprove];
+        if (value === ChatPermissionLevel.Autopilot) {
+            return ChatPermissionLevel.Default;
+        }
+        return isChatPermissionLevel(value) ? value : ChatPermissionLevel.Default;
+    }
+    _readIsWellKnown(reader) {
+        this._configChangedSignal.read(reader);
+        const session = this._session.read(reader);
+        if (!session) {
+            return false;
+        }
+        const provider = this._getProvider(session.providerId);
+        if (!provider) {
+            return false;
+        }
+        const schema = provider.getSessionConfig(session.sessionId)?.schema.properties[SessionConfigKey.AutoApprove];
+        return !!schema && isWellKnownAutoApproveSchema(schema);
+    }
+    _getProvider(providerId) {
+        const provider = this._sessionsProvidersService.getProvider(providerId);
+        return provider && isAgentHostProvider(provider) ? provider : undefined;
+    }
+    _watchProviders(providers) {
+        for (const provider of providers) {
+            if (!isAgentHostProvider(provider) || ( this._providerSubscriptions.has(provider.id))) {
+                continue;
+            }
+            const subscriptions = ( new DisposableStore());
+            subscriptions.add(provider.onDidChangeSessionConfig(() => {
+                this._configChangedSignal.trigger(undefined);
+            }));
+            this._providerSubscriptions.set(provider.id, subscriptions);
+        }
+    }
+};
+AgentHostPermissionPickerDelegate = ( __decorate([( __param(1, ISessionsProvidersService)), ( __param(2, IConfigurationService)), ( __param(3, IAgentHostEnablementService)), ( __param(4, IChatPhoneInputPresenter)), ( __param(5, IAgentHostConnectionsService)), ( __param(6, ILogService))], AgentHostPermissionPickerDelegate));
+function isWellKnownClaudePermissionModeSchema(schema) {
+    if (schema.type !== "string" || !Array.isArray(schema.enum) || schema.enum.length === 0) {
+        return false;
+    }
+    if (!schema.enum.includes(REQUIRED_PERMISSION_MODE_VALUE)) {
+        return false;
+    }
+    return schema.enum.every(value => narrowClaudePermissionMode(value) !== undefined);
+}
+function isWellKnownCodexApprovalsSchema(schema) {
+    if (schema.type !== "string" || !Array.isArray(schema.enum) || schema.enum.length === 0) {
+        return false;
+    }
+    if (!schema.enum.includes(REQUIRED_CODEX_APPROVALS_VALUE)) {
+        return false;
+    }
+    return schema.enum.every(value => narrowCodexPermissionsPreset(value) !== undefined);
+}
+
+export { AgentHostPermissionPickerDelegate, isWellKnownClaudePermissionModeSchema, isWellKnownCodexApprovalsSchema };

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/agentHostSessionBranchActions.d.ts

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

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/agentHostSessionBranchActions.js

@@ -0,0 +1,94 @@
+
+import { localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { registerAction2, Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IClipboardService } from '@codingame/monaco-vscode-api/vscode/vs/platform/clipboard/common/clipboardService.service';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { IAgentHostConnectionsService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostConnectionsService.service';
+import { buildExternalOpenSessionLinkUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/openSessionLink';
+import { ANY_AGENT_HOST_PROVIDER_RE } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+import { SessionProviderIdContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { COPY_AGENT_HOST_SESSION_LINK_COMMAND_ID, COPY_AGENT_HOST_CHAT_LINK_COMMAND_ID } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionCommands';
+import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
+import { SessionItemContextMenuId, SessionItemHasBranchNameContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/views/sessionsList';
+
+function getSession(context) {
+    return Array.isArray(context) ? context[0] : context;
+}
+function buildExternalLink(accessor, session, chatId) {
+    const identity = accessor.get(IAgentHostConnectionsService).resolveSessionResourceIdentity(session.resource);
+    if (!identity) {
+        throw ( new Error(`Cannot resolve Agent Host session resource ${( session.resource.toString())}`));
+    }
+    return buildExternalOpenSessionLinkUri(accessor.get(IProductService).urlProtocol, identity.backendSession, chatId);
+}
+registerAction2(class CopyAgentHostSessionLinkAction extends Action2 {
+    constructor() {
+        super({
+            id: COPY_AGENT_HOST_SESSION_LINK_COMMAND_ID,
+            title: ( localize2(4207, "Copy Link")),
+            menu: [{
+                id: SessionItemContextMenuId,
+                group: "2_open",
+                order: 2,
+                when: ( ContextKeyExpr.regex(SessionProviderIdContext.key, ANY_AGENT_HOST_PROVIDER_RE))
+            }, {
+                id: Menus.SessionHeaderContext,
+                group: "2_edit",
+                order: 2,
+                when: ( ContextKeyExpr.regex(SessionProviderIdContext.key, ANY_AGENT_HOST_PROVIDER_RE))
+            }]
+        });
+    }
+    async run(accessor, context) {
+        const session = getSession(context);
+        if (!session) {
+            return;
+        }
+        await accessor.get(IClipboardService).writeText(buildExternalLink(accessor, session));
+    }
+});
+registerAction2(class CopyAgentHostChatLinkAction extends Action2 {
+    constructor() {
+        super({
+            id: COPY_AGENT_HOST_CHAT_LINK_COMMAND_ID,
+            title: ( localize2(4208, "Copy Link")),
+            menu: [{
+                id: Menus.SessionChatItemContext,
+                group: "2_copy",
+                order: 1,
+                when: ( ContextKeyExpr.regex(SessionProviderIdContext.key, ANY_AGENT_HOST_PROVIDER_RE))
+            }]
+        });
+    }
+    async run(accessor, context) {
+        if (!context) {
+            return;
+        }
+        await accessor.get(IClipboardService).writeText(
+            buildExternalLink(accessor, context.session, context.chat.resource.fragment || undefined)
+        );
+    }
+});
+registerAction2(class CopySessionBranchNameAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessionsViewPane.agentHost.copySessionBranchName",
+            title: ( localize2(4209, "Copy Branch Name")),
+            menu: [{
+                id: SessionItemContextMenuId,
+                group: "2_open",
+                order: 3,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.regex(SessionProviderIdContext.key, ANY_AGENT_HOST_PROVIDER_RE)), SessionItemHasBranchNameContext))
+            }]
+        });
+    }
+    async run(accessor, context) {
+        const session = getSession(context);
+        const branchName = session?.workspace.get()?.folders[0]?.gitRepository?.branchName?.trim();
+        if (!branchName) {
+            return;
+        }
+        await accessor.get(IClipboardService).writeText(branchName);
+    }
+});