@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxService.js

@@ -31,6 +31,7 @@ import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/c
 import { IRemoteAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
 import { WillShutdownJoinerOrder } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle';
 import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { getTerminalOutputDirectory } from './terminalOutput.js';
 
 const SANDBOX_TEMP_DIR_NAME = "tmp";
 function affectsSandboxSettings(e) {
@@ -71,6 +72,7 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
             getUserHome: () => this._resolveUserHome(),
             getSandboxTempDir: () => this._resolveSandboxTempDir(),
             getWorkspaceStorageReadRoot: () => this._resolveWorkspaceStorageReadRoot(),
+            getReadRoots: () => [getTerminalOutputDirectory(this._environmentService.cacheHome)],
             getWriteRoots: () => ( this._workspaceContextService.getWorkspace().folders.map(folder => folder.uri)),
             onDidChangeRoots: this._onDidChangeRoots.event,
             checkSandboxDependencies: () => this._resolveSandboxDependencyStatus(),
@@ -90,7 +92,7 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
             }
             e.join(this._engine.cleanupTempDir(), {
                 id: "join.deleteFilesInSandboxTempDir",
-                label: ( localize(15518, "Delete Files in Sandbox Temp Dir")),
+                label: ( localize(17278, "Delete Files in Sandbox Temp Dir")),
                 order: WillShutdownJoinerOrder.Default
             });
         }));
@@ -162,17 +164,20 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
                 appRoot: remoteEnv.os === OperatingSystem.Windows ? this._toWindowsPath(remoteEnv.appRoot) : remoteEnv.appRoot.path,
                 execPath: remoteEnv.execPath,
                 runAsNode: false,
-                arch: remoteEnv.arch
+                arch: remoteEnv.arch,
+                nativeModulesDir: "node_modules"
             };
         }
         const localAppRootUri = ( FileAccess.asFileUri(""));
         const localAppRoot = OS === OperatingSystem.Windows ? dirname(localAppRootUri.fsPath) : dirname(localAppRootUri.path);
         const nativeEnv = this._environmentService;
+        const nativeModulesDir = this._environmentService.isBuilt ? "node_modules.asar.unpacked" : "node_modules";
         return {
             appRoot: localAppRoot,
             execPath: nativeEnv.execPath,
             runAsNode: true,
-            arch
+            arch,
+            nativeModulesDir
         };
     }
     _toWindowsPath(uri) {
@@ -268,8 +273,19 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
         return this._sandboxHelperService.buildWindowsMxcSandboxPayload(commandLine, policy, workingDirectory, containerName, containment);
     }
     async installMissingSandboxDependencies(missingDependencies, sessionResource, token, options) {
-        const depsList = missingDependencies.join(" ");
-        return this._runSandboxPrerequisiteCommand(`sudo apt install -y ${depsList}`, sessionResource, token, options);
+        const status = await this._resolveSandboxDependencyStatus();
+        if (!status?.dependencyInstallCommand) {
+            return {
+                exitCode: undefined
+            };
+        }
+        const depsList = ( missingDependencies.map(dependency => this._quoteShellArgument(dependency))).join(" ");
+        return this._runSandboxPrerequisiteCommand(
+            `${status.dependencyInstallCommand} ${depsList}`,
+            sessionResource,
+            token,
+            options
+        );
     }
     async runSandboxRemediation(remediation, sessionResource, token, options) {
         let command;
@@ -329,6 +345,9 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
             exitCode: await completionPromise
         };
     }
+    _quoteShellArgument(value) {
+        return `'${value.replace(/'/g, `'\\''`)}'`;
+    }
     _createMissingDependencyPasswordPrompt(sessionResource, promptContext, token) {
         const chatModel = sessionResource && this._chatService.getSession(sessionResource);
         if (!(chatModel instanceof ChatModel)) {
@@ -338,10 +357,10 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
         if (!request) {
             return ( new DisposableStore());
         }
-        const part = ( new ChatElicitationRequestPart(( localize(15519, "The terminal is awaiting input.")), ( new MarkdownString(( localize(
-            15520,
+        const part = ( new ChatElicitationRequestPart(( localize(17279, "The terminal is awaiting input.")), ( new MarkdownString(( localize(
+            17280,
             "Applying sandbox prerequisites may prompt for your sudo password. Select Focus Terminal to type it in the terminal."
-        )))), "", ( localize(15521, "Focus Terminal")), undefined, async () => {
+        )))), "", ( localize(17281, "Focus Terminal")), undefined, async () => {
             await promptContext.focusTerminal();
             return ElicitationState.Pending;
         }));

package/vscode/src/vs/workbench/services/accounts/browser/defaultAccount.d.ts

@@ -0,0 +1,205 @@
+import { ICopilotTokenInfo, IDefaultAccount, IDefaultAccountAuthenticationProvider, IPolicyData } from "@codingame/monaco-vscode-api/vscode/vs/base/common/defaultAccount";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { RawContextKey } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IDefaultAccountProvider, IDefaultAccountRefreshOptions, IManagedSettingsCompatibilityError, ManagedSettingsFetchStatus } from "@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount";
+import { IDefaultAccountService } from "@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IFileManagedSettingsService } from "@codingame/monaco-vscode-api/vscode/vs/platform/policy/common/copilotManagedSettings.service";
+import { INativeManagedSettingsService } from "@codingame/monaco-vscode-api/vscode/vs/platform/policy/common/copilotManagedSettings.service";
+import { IManagedSettingsFreshness } from "@codingame/monaco-vscode-api/vscode/vs/platform/policy/common/managedSettingsFreshness";
+import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
+import { IRequestService } from "@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IAuthenticationExtensionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication.service";
+import { IAuthenticationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication.service";
+import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { IHostService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service";
+interface IDefaultAccountConfig {
+    readonly preferredExtensions: string[];
+    readonly authenticationProvider: {
+        readonly default: {
+            readonly id: string;
+            readonly name: string;
+        };
+        readonly enterprise: {
+            readonly id: string;
+            readonly name: string;
+        };
+        readonly enterpriseProviderConfig: string;
+        readonly enterpriseProviderUriSetting: string;
+        readonly scopes: string[][];
+    };
+    readonly tokenEntitlementUrl: string;
+    readonly entitlementUrl: string;
+    readonly mcpRegistryDataUrl: string;
+    readonly managedSettingsUrl: string;
+}
+export declare const DEFAULT_ACCOUNT_SIGN_IN_COMMAND = "workbench.actions.accounts.signIn";
+export declare enum DefaultAccountStatus {
+    Uninitialized = "uninitialized",
+    Unavailable = "unavailable",
+    Available = "available"
+}
+export declare const CONTEXT_DEFAULT_ACCOUNT_STATE: RawContextKey<string>;
+export declare class DefaultAccountService extends Disposable implements IDefaultAccountService {
+    _serviceBrand: undefined;
+    private defaultAccount;
+    get currentDefaultAccount(): IDefaultAccount | null;
+    get policyData(): IPolicyData | null;
+    get copilotTokenInfo(): ICopilotTokenInfo | null;
+    get managedSettingsFetchStatus(): ManagedSettingsFetchStatus;
+    get managedSettingsFetchedAt(): number | null;
+    get managedSettingsRawResponse(): unknown;
+    get managedSettingsCompatibilityError(): IManagedSettingsCompatibilityError | null;
+    get managedSettingsFreshness(): IManagedSettingsFreshness;
+    private readonly initBarrier;
+    private readonly _onDidChangeDefaultAccount;
+    readonly onDidChangeDefaultAccount: Event<IDefaultAccount | null>;
+    private readonly _onDidChangePolicyData;
+    readonly onDidChangePolicyData: Event<IPolicyData | null>;
+    private readonly _onDidChangeCopilotTokenInfo;
+    readonly onDidChangeCopilotTokenInfo: Event<ICopilotTokenInfo | null>;
+    private readonly _onDidChangeManagedSettingsCompatibilityError;
+    readonly onDidChangeManagedSettingsCompatibilityError: Event<IManagedSettingsCompatibilityError | null>;
+    private readonly _onDidChangeManagedSettingsFreshness;
+    readonly onDidChangeManagedSettingsFreshness: Event<IManagedSettingsFreshness>;
+    private readonly defaultAccountConfig?;
+    private defaultAccountProvider;
+    constructor(productService: IProductService);
+    getDefaultAccount(): Promise<IDefaultAccount | null>;
+    getDefaultAccountAuthenticationProvider(): IDefaultAccountAuthenticationProvider;
+    setDefaultAccountProvider(provider: IDefaultAccountProvider): void;
+    refresh(options?: IDefaultAccountRefreshOptions): Promise<IDefaultAccount | null>;
+    signIn(options?: {
+        additionalScopes?: readonly string[];
+        [key: string]: unknown;
+    }): Promise<IDefaultAccount | null>;
+    signOut(): Promise<void>;
+    resolveGitHubUrl(path: string): string;
+    private setDefaultAccount;
+}
+export declare class DefaultAccountProvider extends Disposable implements IDefaultAccountProvider {
+    private readonly defaultAccountConfig;
+    private readonly configurationService;
+    private readonly authenticationService;
+    private readonly authenticationExtensionsService;
+    private readonly telemetryService;
+    private readonly extensionService;
+    private readonly requestService;
+    private readonly logService;
+    private readonly environmentService;
+    private readonly productService;
+    private readonly storageService;
+    private readonly hostService;
+    private readonly commandService;
+    private readonly nativeManagedSettingsService;
+    private readonly fileManagedSettingsService;
+    private _defaultAccount;
+    get defaultAccount(): IDefaultAccount | null;
+    private _policyData;
+    get policyData(): IPolicyData | null;
+    private _copilotTokenInfo;
+    get copilotTokenInfo(): ICopilotTokenInfo | null;
+    private _managedSettingsFetchStatus;
+    get managedSettingsFetchStatus(): ManagedSettingsFetchStatus;
+    get managedSettingsFetchedAt(): number | null;
+    private _managedSettingsRawResponse;
+    get managedSettingsRawResponse(): unknown;
+    private _managedSettingsCompatibilityError;
+    get managedSettingsCompatibilityError(): IManagedSettingsCompatibilityError | null;
+    private _managedSettingsFreshness;
+    get managedSettingsFreshness(): IManagedSettingsFreshness;
+    private readonly _onDidChangeDefaultAccount;
+    readonly onDidChangeDefaultAccount: Event<IDefaultAccount | null>;
+    private readonly _onDidChangePolicyData;
+    readonly onDidChangePolicyData: Event<IPolicyData | null>;
+    private readonly _onDidChangeCopilotTokenInfo;
+    readonly onDidChangeCopilotTokenInfo: Event<ICopilotTokenInfo | null>;
+    private readonly _onDidChangeManagedSettingsCompatibilityError;
+    readonly onDidChangeManagedSettingsCompatibilityError: Event<IManagedSettingsCompatibilityError | null>;
+    private readonly _onDidChangeManagedSettingsFreshness;
+    readonly onDidChangeManagedSettingsFreshness: Event<IManagedSettingsFreshness>;
+    private readonly accountStatusContext;
+    private initialized;
+    private readonly initPromise;
+    private readonly updateThrottler;
+    private readonly accountDataPollScheduler;
+    private readonly failedManagedSettingsFreshness;
+    constructor(defaultAccountConfig: IDefaultAccountConfig, configurationService: IConfigurationService, authenticationService: IAuthenticationService, authenticationExtensionsService: IAuthenticationExtensionsService, telemetryService: ITelemetryService, extensionService: IExtensionService, requestService: IRequestService, logService: ILogService, environmentService: IWorkbenchEnvironmentService, productService: IProductService, contextKeyService: IContextKeyService, storageService: IStorageService, hostService: IHostService, commandService: ICommandService, nativeManagedSettingsService: INativeManagedSettingsService, fileManagedSettingsService: IFileManagedSettingsService);
+    private getCachedAccountData;
+    private init;
+    private whenDefaultAccountAuthenticationProviderAvailable;
+    refresh(options?: IDefaultAccountRefreshOptions): Promise<IDefaultAccount | null>;
+    private refetchDefaultAccount;
+    private updateDefaultAccount;
+    private doUpdateDefaultAccount;
+    private fetchDefaultAccount;
+    private isAccountProviderAvailable;
+    private setDefaultAccount;
+    private setPolicyData;
+    private setManagedSettingsCompatibilityError;
+    private setManagedSettingsFreshness;
+    private blockPendingManagedSettingsFreshness;
+    private updateManagedSettingsFreshnessRequirement;
+    private onManagedSettingsSourceChanged;
+    private initializeManagedSettingsSources;
+    private blockManagedSettingsFreshnessWithoutToken;
+    private getCachedServerManagedSettings;
+    private getScopedServerManagedSettings;
+    private setCopilotTokenInfo;
+    private cachePolicyData;
+    private scheduleAccountDataPoll;
+    private extractFromToken;
+    private getDefaultAccountForAuthenticationProvider;
+    private getDefaultAccountFromAuthenticatedSessions;
+    private findMatchingProviderSession;
+    private getSessions;
+    private scopesMatch;
+    private getTokenEntitlements;
+    private requestTokenEntitlements;
+    private getEntitlements;
+    private getMcpRegistryProvider;
+    private requestMcpRegistryProvider;
+    private getManagedSettings;
+    private createManagedSettingsFreshnessScope;
+    private resolveManagedSettingsFreshnessAfterSuccess;
+    private toBlockedManagedSettingsFreshness;
+    private requestManagedSettings;
+    private canRequestManagedSettings;
+    private updateFailedManagedSettingsFreshness;
+    private getManagedSettingsScopeKey;
+    private readManagedSettingsCompatibilityError;
+    private reportManagedSettingsOutcome;
+    /**
+     * Detects a rate-limited GitHub response. Mirrors the public-API check in
+     * `githubRepoFetcher.ts`:
+     * - Canonical `429 Too Many Requests`.
+     * - Primary quota exhaustion: `403` with `X-RateLimit-Remaining: 0`.
+     * - Secondary throttling: GitHub omits `X-RateLimit-Remaining` but sets
+     *   `Retry-After` (on a non-2xx response). We treat any non-success status
+     *   that carries `Retry-After` as a back-off signal.
+     */
+    private isRateLimited;
+    private _rateLimitBackoffUntil;
+    private request;
+    private isDataStale;
+    private getEntitlementUrl;
+    private getTokenEntitlementUrl;
+    private getMcpRegistryDataUrl;
+    private getManagedSettingsUrl;
+    getDefaultAccountAuthenticationProvider(): IDefaultAccountAuthenticationProvider;
+    resolveGitHubUrl(path: string): string;
+    private getEnterpriseUrl;
+    signIn(options?: {
+        additionalScopes?: readonly string[];
+        [key: string]: unknown;
+    }): Promise<IDefaultAccount | null>;
+    signOut(): Promise<void>;
+}
+export {};