feat: package manager permissions when using API

Author: karthiknadig

package.json

@@ -231,6 +231,18 @@
                 "title": "%python-envs.copyProjectPath.title%",
                 "category": "Python Envs",
                 "icon": "$(copy)"
+            },
+            {
+                "command": "python-envs.permissions",
+                "title": "%python-envs.permissions.title%",
+                "category": "Python Envs",
+                "icon": "$(shield)"
+            },
+            {
+                "command": "python-envs.resetPermissions",
+                "title": "%python-envs.resetPermissions.title%",
+                "category": "Python Envs",
+                "icon": "$(sync)"
             }
         ],
         "menus": {
@@ -418,9 +430,17 @@
                 },
                 {
                     "command": "python-envs.refreshAllManagers",
+                    "when": "view == env-managers"
+                },
+                {
+                    "command": "python-envs.permissions",
                     "group": "navigation",
                     "when": "view == env-managers"
                 },
+                {
+                    "command": "python-envs.resetPermissions",
+                    "when": "view == env-managers"
+                },
                 {
                     "command": "python-envs.terminal.activate",
                     "group": "navigation",

package.nls.json

@@ -28,5 +28,7 @@
     "python-envs.runAsTask.title": "Run as Task",
     "python-envs.terminal.activate.title": "Activate Environment in Current Terminal",
     "python-envs.terminal.deactivate.title": "Deactivate Environment in Current Terminal",
-    "python-envs.uninstallPackage.title": "Uninstall Package"
+    "python-envs.uninstallPackage.title": "Uninstall Package",
+    "python-envs.permissions.title": "Package Manager Permissions",
+    "python-envs.resetPermissions.title": "Reset Package Manager Permissions"
 }

src/api.ts

@@ -918,7 +918,7 @@ export interface PythonPackageManagementApi {
      * @param environment The Python Environment from which packages are to be uninstalled.
      * @param packages The packages to uninstall.
      */
-    uninstallPackages(environment: PythonEnvironment, packages: PackageInfo[] | string[]): Promise<void>;
+    uninstallPackages(environment: PythonEnvironment, packages: string[]): Promise<void>;
 }
 
 export interface PythonPackageManagerApi

src/common/command.api.ts

@@ -1,6 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { commands } from 'vscode';
+import { Disposable } from 'vscode-jsonrpc';
 
 export function executeCommand<T = unknown>(command: string, ...rest: any[]): Thenable<T> {
     return commands.executeCommand(command, ...rest);
 }
+
+export function registerCommand(command: string, callback: (...args: any[]) => any, thisArg?: any): Disposable {
+    return commands.registerCommand(command, callback, thisArg);
+}

src/common/localize.ts

@@ -144,3 +144,10 @@ export namespace EnvViewStrings {
     export const selectedGlobalTooltip = l10n.t('This environment is selected for non-workspace files');
     export const selectedWorkspaceTooltip = l10n.t('This environment is selected for workspace files');
 }
+
+export namespace PermissionsCommon {
+    export const allow = l10n.t('Allow');
+    export const deny = l10n.t('Deny');
+    export const ask = l10n.t('Ask');
+    export const setPermissions = l10n.t('Set Permissions');
+}

src/common/utils/frameUtils.ts

@@ -1,7 +1,9 @@
+import * as path from 'path';
+import { Uri } from 'vscode';
 import { ENVS_EXTENSION_ID, PYTHON_EXTENSION_ID } from '../constants';
 import { parseStack } from '../errors/utils';
 import { allExtensions, getExtension } from '../extension.apis';
-
+import { normalizePath } from './pathUtils';
 interface FrameData {
     filePath: string;
     functionName: string;
@@ -15,38 +17,64 @@ function getFrameData(): FrameData[] {
     }));
 }
 
+function getPathFromFrame(frame: FrameData): string {
+    if (frame.filePath && frame.filePath.startsWith('file://')) {
+        return Uri.parse(frame.filePath).fsPath;
+    }
+    return frame.filePath;
+}
+
 export function getCallingExtension(): string {
     const pythonExts = [ENVS_EXTENSION_ID, PYTHON_EXTENSION_ID];
-
+    const execPath = normalizePath(path.dirname(process.execPath));
     const extensions = allExtensions();
     const otherExts = extensions.filter((ext) => !pythonExts.includes(ext.id));
-    const frames = getFrameData().filter((frame) => !!frame.filePath);
+    const frames = getFrameData();
+    const filePaths: string[] = [];
 
     for (const frame of frames) {
-        const filename = frame.filePath;
-        if (filename) {
-            const ext = otherExts.find((ext) => filename.includes(ext.id));
-            if (ext) {
-                return ext.id;
-            }
+        if (!frame || !frame.filePath) {
+            continue;
+        }
+        const filePath = normalizePath(getPathFromFrame(frame));
+        if (!filePath) {
+            continue;
+        }
+
+        if (filePath.startsWith(execPath) && filePath.endsWith('extensionhostprocess.js')) {
+            continue;
+        }
+
+        if (filePath.startsWith('node:')) {
+            continue;
+        }
+
+        filePaths.push(filePath);
+
+        const ext = otherExts.find((ext) => filePath.includes(ext.id));
+        if (ext) {
+            return ext.id;
         }
     }
 
     // `ms-python.vscode-python-envs` extension in Development mode
-    const candidates = frames.filter((frame) => otherExts.some((s) => frame.filePath.includes(s.extensionPath)));
-    const envsExtPath = getExtension(ENVS_EXTENSION_ID)?.extensionPath;
-    if (!envsExtPath) {
+    const candidates = filePaths.filter((filePath) =>
+        otherExts.some((s) => filePath.includes(normalizePath(s.extensionPath))),
+    );
+    const envExt = getExtension(ENVS_EXTENSION_ID);
+
+    if (!envExt) {
         throw new Error('Something went wrong with feature registration');
     }
-
-    if (candidates.length === 0 && frames.every((frame) => frame.filePath.startsWith(envsExtPath))) {
+    const envsExtPath = normalizePath(envExt.extensionPath);
+    if (candidates.length === 0 && filePaths.every((filePath) => filePath.startsWith(envsExtPath))) {
         return PYTHON_EXTENSION_ID;
-    }
-
-    // 3rd party extension in Development mode
-    const candidateExt = otherExts.find((ext) => candidates[0].filePath.includes(ext.extensionPath));
-    if (candidateExt) {
-        return candidateExt.id;
+    } else if (candidates.length > 0) {
+        // 3rd party extension in Development mode
+        const candidateExt = otherExts.find((ext) => candidates[0].includes(ext.extensionPath));
+        if (candidateExt) {
+            return candidateExt.id;
+        }
     }
 
     throw new Error('Unable to determine calling extension id, registration failed');

src/common/utils/pathUtils.ts

@@ -1,10 +1,9 @@
-import * as path from 'path';
+import { isWindows } from '../../managers/common/utils';
 
-export function areSamePaths(a: string, b: string): boolean {
-    return path.resolve(a) === path.resolve(b);
-}
-
-export function isParentPath(parent: string, child: string): boolean {
-    const relative = path.relative(path.resolve(parent), path.resolve(child));
-    return !!relative && !relative.startsWith('..') && !path.isAbsolute(relative);
+export function normalizePath(path: string): string {
+    const path1 = path.replace(/\\/g, '/');
+    if (isWindows()) {
+        return path1.toLowerCase();
+    }
+    return path1;
 }

src/common/window.apis.ts

@@ -7,6 +7,8 @@ import {
     InputBox,
     InputBoxOptions,
     LogOutputChannel,
+    MessageItem,
+    MessageOptions,
     OpenDialogOptions,
     OutputChannel,
     Progress,
@@ -288,6 +290,22 @@ export function showWarningMessage(message: string, ...items: string[]): Thenabl
     return window.showWarningMessage(message, ...items);
 }
 
+export function showInformationMessage<T extends string>(message: string, ...items: T[]): Thenable<T | undefined>;
+export function showInformationMessage<T extends string>(
+    message: string,
+    options: MessageOptions,
+    ...items: T[]
+): Thenable<T | undefined>;
+export function showInformationMessage<T extends MessageItem>(message: string, ...items: T[]): Thenable<T | undefined>;
+export function showInformationMessage<T extends MessageItem>(
+    message: string,
+    options: MessageOptions,
+    ...items: T[]
+): Thenable<T | undefined>;
+export function showInformationMessage(message: string, ...items: any[]): Thenable<string | undefined> {
+    return window.showInformationMessage(message, ...items);
+}
+
 export function showInputBox(options?: InputBoxOptions, token?: CancellationToken): Thenable<string | undefined> {
     return window.showInputBox(options, token);
 }

src/extension.ts

@@ -23,6 +23,7 @@ import {
     runInDedicatedTerminalCommand,
     handlePackageUninstall,
     copyPathToClipboard,
+    getUninstallPackages,
 } from './features/envCommands';
 import { registerCondaFeatures } from './managers/conda/main';
 import { registerSystemPythonFeatures } from './managers/builtin/main';
@@ -57,6 +58,11 @@ import { registerTools } from './common/lm.apis';
 import { GetPackagesTool } from './features/copilotTools';
 import { TerminalActivationImpl } from './features/terminal/terminalActivationState';
 import { getEnvironmentForTerminal } from './features/terminal/utils';
+import {
+    checkPackageManagementPermissions,
+    handlePermissionsCommand,
+    PackageManagerPermissionsImpl,
+} from './features/permissions/packageManagerPermissions';
 
 export async function activate(context: ExtensionContext): Promise<PythonEnvironmentApi> {
     const start = new StopWatch();
@@ -93,7 +99,9 @@ export async function activate(context: ExtensionContext): Promise<PythonEnviron
         projectCreators.registerPythonProjectCreator(new AutoFindProjects(projectManager)),
     );
 
-    setPythonApi(envManagers, projectManager, projectCreators, terminalManager, envVarManager);
+    const pkgPerm = new PackageManagerPermissionsImpl(context.secrets);
+
+    setPythonApi(envManagers, projectManager, projectCreators, terminalManager, envVarManager, pkgPerm);
 
     const managerView = new EnvManagerView(envManagers);
     context.subscriptions.push(managerView);
@@ -109,6 +117,12 @@ export async function activate(context: ExtensionContext): Promise<PythonEnviron
     context.subscriptions.push(
         registerCompletionProvider(envManagers),
         registerTools('python_get_packages', new GetPackagesTool(api)),
+        commands.registerCommand('python-envs.permissions', async () => {
+            await handlePermissionsCommand(pkgPerm);
+        }),
+        commands.registerCommand('python-envs.resetPermissions', async () => {
+            await pkgPerm.resetPermissions();
+        }),
         commands.registerCommand('python-envs.viewLogs', () => outputChannel.show()),
         commands.registerCommand('python-envs.refreshManager', async (item) => {
             await refreshManagerCommand(item);
@@ -138,9 +152,20 @@ export async function activate(context: ExtensionContext): Promise<PythonEnviron
                 envManagers,
                 projectManager,
             );
-            await handlePackagesCommand(packageManager, environment);
+
+            const result = await checkPackageManagementPermissions(pkgPerm, 'changes');
+            if (!result) {
+                return;
+            }
+
+            await handlePackagesCommand(environment, packageManager);
         }),
         commands.registerCommand('python-envs.uninstallPackage', async (context: unknown) => {
+            const result = await checkPackageManagementPermissions(pkgPerm, 'uninstall', getUninstallPackages(context));
+            if (!result) {
+                return;
+            }
+
             await handlePackageUninstall(context, envManagers);
         }),
         commands.registerCommand('python-envs.set', async (item) => {

src/features/envCommands.ts

@@ -181,8 +181,8 @@ export async function removeEnvironmentCommand(context: unknown, managers: Envir
 }
 
 export async function handlePackagesCommand(
-    packageManager: InternalPackageManager,
     environment: PythonEnvironment,
+    packageManager: InternalPackageManager,
 ): Promise<void> {
     const action = await pickPackageOptions();
 
@@ -194,12 +194,21 @@ export async function handlePackagesCommand(
         }
     } catch (ex) {
         if (ex === QuickInputButtons.Back) {
-            return handlePackagesCommand(packageManager, environment);
+            return handlePackagesCommand(environment, packageManager);
         }
         throw ex;
     }
 }
 
+export function getUninstallPackages(context: unknown): string[] | undefined {
+    if (context instanceof PackageTreeItem) {
+        return [(context as PackageTreeItem).pkg.name];
+    } else if (context instanceof ProjectPackage) {
+        return [(context as ProjectPackage).pkg.name];
+    }
+    return undefined;
+}
+
 export async function handlePackageUninstall(context: unknown, em: EnvironmentManagers) {
     if (context instanceof PackageTreeItem || context instanceof ProjectPackage) {
         const moduleName = context.pkg.name;