feat: add support for file navigation root (#1557)

**Summary**
This introduces a number of changes. First, there were a couple of minor changes not specifically related to this issue:
 - I updated the "delete resource" command to bail early and got rid of one level of navigation
 - I renamed the various "file" adapters such that they are named consistently w/ the following format: `<Technology><Server|Content>Adapter` (i.e. `RestContentAdapter`, `ItcServerAdapter`)

Next, this adds configuration options for `fileNavigationCustomRootPath` and `fileNavigationRoot`. A few things to mention with this one:
 - using `fileNavigationRoot === 'SYSTEM'` for itc connections has the ability to set the root folder as the system root (i.e. `C:\`). At the moment, `fileNavigationRoot === 'SYSTEM'` has no effect on rest connection types.
 - If `fileNavigationCustomRootPath` is specified, it'll basically be ignored _until_ `fileNavigationRoot === 'CUSTOM'`
 - If `fileNavigationCustomRootPath` is specified and `fileNavigationRoot === 'CUSTOM'`, sas server files are loaded with the `Home` directory pointing to `fileNavigationCustomRootPath`
    - NOTE: If `fileNavigationCustomRootPath` does not exist, an error is displayed to the user pointing them to their settings
    - Also, a new context menu item, "Copy Path," was introduced to make it easier to see what path is at the root, as well as making it easier to define a new `fileNavigationCustomRootPath`. "Copy Path" is available for sas server & content files with any connection type

**Testing**
 - [x] Test defining various combinations of `fileNavigationCustomRootPath` and `fileNavigationRoot`
 - [x]  Made sure `fileNavigationCustomRootPath` failures provided some detail to end-users
 - [x]  Made sure paths could be copied for files and folders, but not for things in favorites/recycle bin. Made sure paths could also be copied for root folders under rest/itc-based connections
 - [x] Made sure compute context settings were prioritized over user-defined settings. 

**Notes on compute-defined file navigation root settings**
One can set file navigation root settings using environment manager, using the attribute names mentioned above. Here's an example: 
<img width="1387" height="970" alt="ev-settings" src="https://github.com/user-attachments/assets/e34b1337-ff71-4173-b832-23a80f33926c" />

If _either_ of the settings are specified by the compute context, they immediately override the user settings.

Author: scottdover

CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). If you introduce breaking changes, please group them together in the "Changed" section using the **BREAKING:** prefix.
 
+## [Unreleased]
+
+### Added
+
+- Add support for `fileNavigationCustomRootPath`/`fileNavigationRoot` for rest & iom/com connections ([#1557](https://github.com/sassoftware/vscode-sas-extension/pull/1557))
+
 ## [v1.15.0] - 2025-06-10
 
 ### Changed

client/src/components/ContentNavigator/ContentAdapterFactory.ts

@@ -1,9 +1,9 @@
 // Copyright © 2024, SAS Institute Inc., Cary, NC, USA.  All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import ITCSASServerAdapter from "../../connection/itc/ITCSASServerAdapter";
-import RestSASServerAdapter from "../../connection/rest/RestSASServerAdapter";
-import SASContentAdapter from "../../connection/rest/SASContentAdapter";
-import { ConnectionType } from "../profile";
+import ItcServerAdapter from "../../connection/itc/ItcServerAdapter";
+import RestContentAdapter from "../../connection/rest/RestContentAdapter";
+import RestServerAdapter from "../../connection/rest/RestServerAdapter";
+import { ConnectionType, ProfileWithFileRootOptions } from "../profile";
 import {
   ContentAdapter,
   ContentNavigatorConfig,
@@ -13,18 +13,26 @@ import {
 class ContentAdapterFactory {
   public create(
     connectionType: ConnectionType,
+    fileNavigationCustomRootPath: ProfileWithFileRootOptions["fileNavigationCustomRootPath"],
+    fileNavigationRoot: ProfileWithFileRootOptions["fileNavigationRoot"],
     sourceType: ContentNavigatorConfig["sourceType"],
   ): ContentAdapter {
     const key = `${connectionType}.${sourceType}`;
     switch (key) {
       case `${ConnectionType.Rest}.${ContentSourceType.SASServer}`:
-        return new RestSASServerAdapter();
+        return new RestServerAdapter(
+          fileNavigationCustomRootPath,
+          fileNavigationRoot,
+        );
       case `${ConnectionType.IOM}.${ContentSourceType.SASServer}`:
       case `${ConnectionType.COM}.${ContentSourceType.SASServer}`:
-        return new ITCSASServerAdapter();
+        return new ItcServerAdapter(
+          fileNavigationCustomRootPath,
+          fileNavigationRoot,
+        );
       case `${ConnectionType.Rest}.${ContentSourceType.SASContent}`:
       default:
-        return new SASContentAdapter();
+        return new RestContentAdapter();
     }
   }
 }

client/src/components/ContentNavigator/ContentDataProvider.ts

@@ -225,7 +225,7 @@ class ContentDataProvider
             arguments: [uri],
             title: "Open SAS File",
           },
-      contextValue: item.contextValue,
+      contextValue: item.contextValue || undefined,
       iconPath: this.iconPathForItem(item),
       id: item.uid,
       label: item.name,
@@ -533,6 +533,10 @@ class ContentDataProvider
     }
   }
 
+  public async getPathOfItem(item: ContentItem) {
+    return await this.model.getPathOfItem(item);
+  }
+
   private async childrenSelections(
     selection: ContentItem,
     allSelections: readonly ContentItem[],

client/src/components/ContentNavigator/ContentModel.ts

@@ -197,4 +197,8 @@ export class ContentModel {
   public async restoreResource(item: ContentItem) {
     return await this.contentAdapter?.restoreItem(item);
   }
+
+  public async getPathOfItem(item: ContentItem): Promise<string> {
+    return await this.contentAdapter.getPathOfItem(item);
+  }
 }

client/src/components/ContentNavigator/const.ts

@@ -74,6 +74,12 @@ export const Messages = {
   FileDragFromFavorites: l10n.t("Unable to drag files from my favorites."),
   FileDragFromTrashError: l10n.t("Unable to drag files from trash."),
   FileDropError: l10n.t('Unable to drop item "{name}".'),
+  FileNavigationRootAdminError: l10n.t(
+    "The files cannot be accessed from the path specified in the context definition for the SAS Compute Server. Contact your SAS administrator.",
+  ),
+  FileNavigationRootUserError: l10n.t(
+    "The files cannot be accessed from the specified path.",
+  ),
   FileOpenError: l10n.t("The file type is unsupported."),
   FileRestoreError: l10n.t("Unable to restore file."),
   FileUploadError: l10n.t("Unable to upload files."),

client/src/components/ContentNavigator/index.ts

@@ -9,14 +9,15 @@ import {
   ProgressLocation,
   Uri,
   commands,
+  env,
   l10n,
   window,
   workspace,
 } from "vscode";
 
 import { profileConfig } from "../../commands/profile";
 import { SubscriptionProvider } from "../SubscriptionProvider";
-import { ConnectionType } from "../profile";
+import { ConnectionType, ProfileWithFileRootOptions } from "../profile";
 import ContentAdapterFactory from "./ContentAdapterFactory";
 import ContentDataProvider from "./ContentDataProvider";
 import { ContentModel } from "./ContentModel";
@@ -102,33 +103,34 @@ class ContentNavigator implements SubscriptionProvider {
         async (item: ContentItem) => {
           this.treeViewSelections(item).forEach(
             async (resource: ContentItem) => {
+              if (!resource.contextValue.includes("delete")) {
+                return;
+              }
               const isContainer = getIsContainer(resource);
               const moveToRecycleBin =
                 this.contentDataProvider.canRecycleResource(resource);
 
-              if (resource.contextValue.includes("delete")) {
-                if (
-                  !moveToRecycleBin &&
-                  !(await window.showWarningMessage(
-                    l10n.t(Messages.DeleteWarningMessage, {
-                      name: resource.name,
-                    }),
-                    { modal: true },
-                    Messages.DeleteButtonLabel,
-                  ))
-                ) {
-                  return;
-                }
-                const deleteResult = moveToRecycleBin
-                  ? await this.contentDataProvider.recycleResource(resource)
-                  : await this.contentDataProvider.deleteResource(resource);
-                if (!deleteResult) {
-                  window.showErrorMessage(
-                    isContainer
-                      ? Messages.FolderDeletionError
-                      : Messages.FileDeletionError,
-                  );
-                }
+              if (
+                !moveToRecycleBin &&
+                !(await window.showWarningMessage(
+                  l10n.t(Messages.DeleteWarningMessage, {
+                    name: resource.name,
+                  }),
+                  { modal: true },
+                  Messages.DeleteButtonLabel,
+                ))
+              ) {
+                return;
+              }
+              const deleteResult = moveToRecycleBin
+                ? await this.contentDataProvider.recycleResource(resource)
+                : await this.contentDataProvider.deleteResource(resource);
+              if (!deleteResult) {
+                window.showErrorMessage(
+                  isContainer
+                    ? Messages.FolderDeletionError
+                    : Messages.FileDeletionError,
+                );
               }
             },
           );
@@ -399,6 +401,15 @@ class ContentNavigator implements SubscriptionProvider {
         async (resource: ContentItem) =>
           this.uploadResource(resource, { canSelectFiles: false }),
       ),
+      commands.registerCommand(
+        `${SAS}.copyPath`,
+        async (resource: ContentItem) => {
+          const path = await this.contentDataProvider.getPathOfItem(resource);
+          if (path) {
+            await env.clipboard.writeText(path);
+          }
+        },
+      ),
       workspace.onDidChangeConfiguration(
         async (event: ConfigurationChangeEvent) => {
           if (event.affectsConfiguration("SAS.connectionProfiles")) {
@@ -490,10 +501,26 @@ class ContentNavigator implements SubscriptionProvider {
       return;
     }
 
+    const profileWithFileRootOptions = getProfileWithFileRootOptions();
     return new ContentAdapterFactory().create(
       activeProfile.connectionType,
+      profileWithFileRootOptions?.fileNavigationCustomRootPath,
+      profileWithFileRootOptions?.fileNavigationRoot,
       this.sourceType,
     );
+
+    function getProfileWithFileRootOptions():
+      | ProfileWithFileRootOptions
+      | undefined {
+      switch (activeProfile.connectionType) {
+        case ConnectionType.Rest:
+        case ConnectionType.IOM:
+        case ConnectionType.COM:
+          return activeProfile;
+        default:
+          return undefined;
+      }
+    }
   }
 }
 

client/src/components/ContentNavigator/types.ts

@@ -80,9 +80,13 @@ export interface ContentAdapter {
   getChildItems: (parentItem: ContentItem) => Promise<ContentItem[]>;
   getContentOfItem: (item: ContentItem) => Promise<string>;
   getContentOfUri: (uri: Uri) => Promise<string>;
-  getFolderPathForItem: (item: ContentItem) => Promise<string>;
+  getFolderPathForItem: (item: ContentItem) => Promise<string> | string;
   getItemOfUri: (uri: Uri) => Promise<ContentItem>;
   getParentOfItem: (item: ContentItem) => Promise<ContentItem | undefined>;
+  getPathOfItem?: (
+    item: ContentItem,
+    folderPathOnly?: boolean,
+  ) => Promise<string>;
   getRootFolder: (name: string) => ContentItem | undefined;
   getRootItems: () => Promise<RootFolderMap>;
   getUriOfItem: (item: ContentItem, readOnly: boolean) => Promise<Uri>;

client/src/components/ContentNavigator/utils.ts

@@ -9,8 +9,17 @@ import {
   window,
 } from "vscode";
 
-import { resourceType } from "../../connection/rest/util";
-import { DEFAULT_FILE_CONTENT_TYPE } from "./const";
+import { basename } from "path";
+
+import { ProfileWithFileRootOptions } from "../profile";
+import {
+  DEFAULT_FILE_CONTENT_TYPE,
+  FILE_TYPES,
+  FOLDER_TYPE,
+  FOLDER_TYPES,
+  SERVER_HOME_FOLDER_TYPE,
+  TRASH_FOLDER_TYPE,
+} from "./const";
 import mimeTypes from "./mime-types";
 import { ContentItem, Permission } from "./types";
 
@@ -102,7 +111,6 @@ export const convertStaticFolderToContentItem = (
       type: FileType.Directory,
     },
   };
-  item.contextValue = resourceType(item);
   item.typeName = staticFolder.type;
   return item;
 };
@@ -130,3 +138,106 @@ export const sortedContentItems = (items: ContentItem[]) =>
       return a.name.localeCompare(b.name);
     }
   });
+
+export const homeDirectoryName = (
+  fileNavigationRoot: ProfileWithFileRootOptions["fileNavigationRoot"],
+  fileNavigationCustomRootPath: ProfileWithFileRootOptions["fileNavigationCustomRootPath"],
+): string => {
+  const defaultName = "Home";
+  if (fileNavigationRoot !== "CUSTOM" || !fileNavigationCustomRootPath) {
+    return defaultName;
+  }
+
+  return basename(fileNavigationCustomRootPath) || defaultName;
+};
+
+export const homeDirectoryNameAndType = (
+  fileNavigationRoot: ProfileWithFileRootOptions["fileNavigationRoot"],
+  fileNavigationCustomRootPath: ProfileWithFileRootOptions["fileNavigationCustomRootPath"],
+): [string, string] => {
+  const directoryName = homeDirectoryName(
+    fileNavigationRoot,
+    fileNavigationCustomRootPath,
+  );
+  if (directoryName === "Home") {
+    return [directoryName, SERVER_HOME_FOLDER_TYPE];
+  }
+
+  return [directoryName, FOLDER_TYPE];
+};
+
+export const getTypeName = (item: ContentItem): string =>
+  item.contentType || item.type;
+
+export const isRootFolder = (item: ContentItem, bStrict?: boolean): boolean => {
+  const typeName = item.typeName;
+  if (!bStrict && isItemInRecycleBin(item) && isReference(item)) {
+    return false;
+  }
+  if (FOLDER_TYPES.indexOf(typeName) >= 0) {
+    return true;
+  }
+  return false;
+};
+
+export enum ContextMenuAction {
+  CreateChild = "createChild", // Create a new folder _under_ the current one
+  Delete = "delete", // The item can be deleted
+  Update = "update", // The item can be updated/edited/renamed
+  Restore = "restore", // The item can be restored
+  CopyPath = "copyPath", // The item path can be copied
+  Empty = "empty", // Whether or not children can be deleted permanently (for the recycling bin)
+  AddToFavorites = "addToFavorites", // Item can be added to favorites
+  RemoveFromFavorites = "removeFromFavorites", // Item can be removed from favorites
+  ConvertNotebookToFlow = "convertNotebookToFlow", // Allows sasnb files to be converted to flows
+  AllowDownload = "allowDownload", // Allows downloading files / folders
+}
+export class ContextMenuProvider {
+  constructor(
+    protected readonly validContextMenuActions: ContextMenuAction[],
+    protected readonly enablementOverrides: Partial<
+      Record<ContextMenuAction, (item: ContentItem) => boolean>
+    > = {},
+  ) {}
+
+  public availableActions(item: ContentItem): string {
+    if (!isValidItem(item)) {
+      return "";
+    }
+
+    const { write, delete: canDelete, addMember } = item.permission;
+    const isRecycled = isItemInRecycleBin(item);
+    const type = getTypeName(item);
+
+    const menuActionEnablement = {
+      [ContextMenuAction.CreateChild]: () => addMember && !isRecycled,
+      [ContextMenuAction.Delete]: () =>
+        canDelete && !item.flags?.isInMyFavorites,
+      [ContextMenuAction.Update]: () => write && !isRecycled,
+      [ContextMenuAction.Restore]: () => write && isRecycled,
+      [ContextMenuAction.CopyPath]: () => (addMember || write) && !isRecycled,
+      [ContextMenuAction.Empty]: () =>
+        type === TRASH_FOLDER_TYPE && !!item?.memberCount,
+      [ContextMenuAction.AddToFavorites]: () =>
+        !item.flags?.isInMyFavorites &&
+        item.type !== "reference" &&
+        [FOLDER_TYPE, ...FILE_TYPES].includes(type) &&
+        !isRecycled,
+      [ContextMenuAction.RemoveFromFavorites]: () =>
+        item.flags?.isInMyFavorites,
+      [ContextMenuAction.ConvertNotebookToFlow]: () =>
+        item?.name?.endsWith(".sasnb"),
+      [ContextMenuAction.AllowDownload]: () => !isRootFolder(item),
+      ...(this.enablementOverrides || {}),
+    };
+
+    const actions = Object.keys(menuActionEnablement)
+      .filter((key: ContextMenuAction) =>
+        this.validContextMenuActions.includes(key),
+      )
+      .filter((key) => menuActionEnablement[key](item))
+      .map((key) => key);
+
+    return actions.sort().join("-");
+  }
+}