badrock integration

package.json

@@ -6,7 +6,7 @@
   },
   "displayName": "NetApp FSx ONTAP",
   "description": "",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "engines": {
     "vscode": "^1.102.0"
   },
@@ -38,6 +38,16 @@
           "type": "string",
           "default": "",
           "description": "Company name"
+        },
+        "netapp-fsx-ontap.bedrockmodel": {
+          "type": "string",
+          "default": "",
+          "description": "Bedrock model"
+        },
+        "netapp-fsx-ontap.bedrockregion": {
+          "type": "string",
+          "default": "us-east-1",
+          "description": "Bedrock region"
         }
       }
     },
@@ -106,6 +116,11 @@
         "category": "NetApp FSx ONTAP",
         "icon": "$(account)"
       },
+      {
+        "command": "netapp-fsx-ontap.update-ontap-login-details",
+        "title": "Configure ONTAP connection details",
+        "category": "NetApp FSx ONTAP"
+      },
       {
         "command": "netapp-fsx-ontap.addSvm",
         "title": "Add SVM",
@@ -200,14 +215,19 @@
           "when": "viewItem == filesystem",
           "group": "inline"
         },
+        {
+          "command": "netapp-fsx-ontap.update-ontap-login-details",
+          "when": "viewItem == filesystem-withLoginDetails",
+          "group": "navigation"
+        },
         {
           "command": "netapp-fsx-ontap.addVolume-terraform",
           "when": "viewItem == svm",
           "group": "navigation"
         },
         {
           "command": "netapp-fsx-ontap.addSvm-cloudformation",
-          "when": "viewItem == filesystem",
+          "when": "viewItem == filesystem || viewItem == filesystem-withLoginDetails",
           "group": "navigation"
         },
         {
@@ -217,7 +237,7 @@
         },
         {
           "command": "netapp-fsx-ontap.addSvm-cli",
-          "when": "viewItem == filesystem",
+          "when": "viewItem == filesystem || viewItem == filesystem-withLoginDetails",
           "group": "navigation"
         },
         {
@@ -227,12 +247,12 @@
         },
         {
           "command": "netapp-fsx-ontap.sshToFileSystem",
-          "when": "viewItem == filesystem",
+          "when": "viewItem == filesystem || viewItem == filesystem-withLoginDetails",
           "group": "inline"
         },
         {
           "command": "netapp-fsx-ontap.addSvm",
-          "when": "viewItem == filesystem",
+          "when": "viewItem == filesystem || viewItem == filesystem-withLoginDetails",
           "group": "inline"
         },
         {
@@ -274,6 +294,7 @@
     "typescript": "^5.8.3"
   },
   "dependencies": {
+    "@aws-sdk/client-bedrock-runtime": "^3.948.0",
     "@aws-sdk/client-cloudwatch": "^3.922.0",
     "@aws-sdk/client-fsx": "^3.922.0",
     "@aws-sdk/client-sts": "^3.922.0",

src/FileSystemsTree.ts

@@ -52,11 +52,13 @@ export class FileSystemsTree implements vscode.TreeDataProvider<vscode.TreeItem>
         } else {
             if(element.contextValue === 'region') {
                 const fileSystems = await listFileSystems(element.id || 'us-east-1');
-                return fileSystems.map(fs => {
+                return Promise.all(fileSystems.map(async fs => {
                     const name = fs.Tags?.find(tag => tag.Key === 'Name')?.Value || fs.FileSystemId;
-                    const fsItem = new FileSystemsItem(name || '', fs.FileSystemId || '', fs, element.id || 'us-east-1', vscode.TreeItemCollapsibleState.Collapsed);
+                    const sshInfoStr = await state.context.secrets.get(`sshKey-${fs.FileSystemId}-${element.id || 'us-east-1'}`);
+                    const fsItem = new FileSystemsItem(name || '', fs.FileSystemId || '', fs, element.id || 'us-east-1',
+                         vscode.TreeItemCollapsibleState.Collapsed, !!sshInfoStr);
                     return fsItem;
-                });
+                }));
             }
             if(element.contextValue === 'filesystem') {
                 const e = element as FileSystemsItem;

src/TreeItems.ts

@@ -8,21 +8,18 @@ export class FileSystemsItem extends vscode.TreeItem {
         public readonly fs: FileSystem,
         public readonly region: string,
 		public readonly collapsibleState: vscode.TreeItemCollapsibleState,
+		public readonly hasOntapLoginDetails: boolean,
 		public readonly command?: vscode.Command
 	) {
 		super(name, collapsibleState);
 
 		this.tooltip = `${this.name}`;
 		this.description = this.id;
-		this.iconPath = new vscode.ThemeIcon('cloud');
+		this.iconPath = this.hasOntapLoginDetails ? new vscode.ThemeIcon('pass-filled') : new vscode.ThemeIcon('cloud'); 
+		this.contextValue = this.hasOntapLoginDetails ? 'filesystem-withLoginDetails' : 'filesystem';
 	}
 
-	/*iconPath = {
-		light: path.join(__filename, '..', '..', 'resources', 'light', 'dependency.svg'),
-		dark: path.join(__filename, '..', '..', 'resources', 'dark', 'dependency.svg')
-	};*/
-
-	contextValue = 'filesystem';
+
 
 }
 

src/chat/modelFactory.ts

@@ -0,0 +1,29 @@
+import * as vscode from 'vscode';
+import { CopilotModel } from './models/copilot';
+import { BedrockModel } from './models/bedrock';
+
+export type MessageType = {
+    role: 'user' | 'assistant' | 'system';
+};
+
+export interface Model {
+    sendMessage: (message: string, messageType: MessageType) => Promise<string>;
+    init: () => Promise<void>;
+    type: string;
+}
+
+
+
+
+export async function getModel(token: vscode.CancellationToken): Promise<Model> {
+    const bedrockModel = vscode.workspace.getConfiguration('netapp-fsx-ontap').get('bedrockmodel',"");
+    if (bedrockModel) {
+        const model = new BedrockModel(bedrockModel as string);
+        await model.init();
+        return model;
+    } else {
+        const model = new CopilotModel(token);
+        await model.init();
+        return model;
+    }
+}

src/chat/models/bedrock.ts

@@ -0,0 +1,54 @@
+import { BedrockRuntimeClient, ConversationRole, ConverseCommand } from "@aws-sdk/client-bedrock-runtime";
+import { MessageType, Model } from "../modelFactory";
+import * as vscode from 'vscode';
+import { state } from "../../state";
+
+export class BedrockModel implements Model {
+    type: string = "bedrock";
+    client: BedrockRuntimeClient | null = null;
+    temperature = 0.7;
+    maxTokens = 4096;
+
+    constructor(private modelName: string) {}
+
+    async init(): Promise<void> {
+        const bedrockRegion = vscode.workspace.getConfiguration('netapp-fsx-ontap').get('bedrockregion',"us-east-1");
+        try {
+            this.client = new BedrockRuntimeClient({
+                region: bedrockRegion as string,
+                profile: state.currentProfile
+            });
+            console.log(`Initialized Bedrock client for model: ${this.modelName} in region: ${bedrockRegion}`);
+        } catch (error) {
+            console.error("Failed to initialize Bedrock client:", error);
+            throw error;
+        }
+
+    }
+
+    async sendMessage(message: string, messageType: MessageType): Promise<string> {
+        const content = [{
+            role: ConversationRole.USER,
+            content: [{ text: message }],
+        }];
+
+        const command = new ConverseCommand({
+            modelId: this.modelName,
+            messages: content,
+
+            inferenceConfig: {
+                maxTokens: this.maxTokens,
+                temperature: this.temperature,
+            },
+        });
+
+        if(!this.client) {
+            throw new Error("Bedrock client not initialized");
+        }
+
+        const response = await this.client.send(command);
+        return response.output?.message?.content?.map(c => c.text).join("") || "";
+
+
+    }
+}

src/chat/models/copilot.ts

@@ -0,0 +1,45 @@
+import * as vscode from 'vscode';
+import { MessageType, Model } from "../modelFactory";
+
+
+export class CopilotModel implements Model {
+    type: string = "copilot";
+    chatModel: vscode.LanguageModelChat | null = null;
+
+    constructor(private token: vscode.CancellationToken) {}
+
+    async getWorkingLanguageModel(): Promise<vscode.LanguageModelChat | null> {
+        const chatModels = await vscode.lm.selectChatModels();
+
+        for (const model of chatModels) {
+            try {
+                // Test the model with a simple request
+                const testMessage = vscode.LanguageModelChatMessage.Assistant('Hello');
+                await model.sendRequest([testMessage], {}, new vscode.CancellationTokenSource().token);
+                return model;
+            } catch (error) {
+                console.warn(`Model ${model.vendor}/${model.name} failed test:`, error);
+                continue;
+            }
+        }
+
+        return null;
+    }
+
+    async init(): Promise<void> {
+        this.chatModel = await this.getWorkingLanguageModel();
+        console.log(`Using language model: ${this.chatModel?.vendor}/${this.chatModel?.name}`);
+    }
+
+    async sendMessage(message: string, messageType: MessageType): Promise<string> {
+        const messageObj = messageType.role === 'user' ? vscode.LanguageModelChatMessage.User(message)
+            : vscode.LanguageModelChatMessage.Assistant(message);
+
+        const request = await this.chatModel?.sendRequest([messageObj], {}, this.token);
+        let response = '';
+        for await (const fragment of request?.text || []) {
+            response = response + fragment;
+        }
+        return response;
+    }
+}

src/commands.ts

@@ -109,13 +109,15 @@ export async function sshToFileSystem(item: any) {
     await SSHService.sshToFileSystem(item.id, item.name, item.region, item.fs.OntapConfiguration.Endpoints.Management.IpAddresses[0]);
 }
 
-export async function addOntapLoginDetails(fileSystem: any)  {
+
+export async function addOntapLoginDetails(fileSystem: any, refreshFunc: () => void)  {
     try{
         const connectionDetails = await SSHService.promptForConnectionDetails(fileSystem.fs.OntapConfiguration.Endpoints.Management.DNSName ,
          fileSystem.id, fileSystem.fs.OntapConfiguration.Endpoints.Management.IpAddresses[0], true);
         await executeOntapCommands(fileSystem.fs, ['volume show'], connectionDetails);
         await state.context.secrets.store(`sshKey-${fileSystem.id}-${fileSystem.region}`, JSON.stringify(connectionDetails));
         vscode.window.showInformationMessage(`ONTAP login details for file system ${fileSystem.id} added successfully.`);
+        refreshFunc();
     } catch (error: any) {
         vscode.window.showErrorMessage(`Error adding ONTAP login details: ${error.message}`);   
     }