Fix: Kiota extension works without a workspace folder open

vscode/microsoft-kiota/src/extension.ts

@@ -25,7 +25,7 @@ import { getLanguageInformation, getLanguageInformationForDescription } from "./
 import { DependenciesViewProvider } from "./dependenciesViewProvider";
 import { updateClients } from "./updateClients";
 import { ExtensionSettings, getExtensionSettings } from "./extensionSettings";
-import {  KiotaWorkspace } from "./workspaceTreeProvider";
+import { loadTreeView } from "./workspaceTreeProvider";
 import { generatePlugin } from "./generatePlugin";
 import { CodeLensProvider } from "./codelensProvider";
 import { KIOTA_DIRECTORY, KIOTA_WORKSPACE_FILE, dependenciesInfo, extensionId, statusBarCommandId, treeViewFocusCommand, treeViewId } from "./constants";
@@ -38,6 +38,11 @@ let clientOrPluginObject: ClientOrPluginProperties;
 let workspaceGenerationType: string;
 let config: Partial<GenerateState>;
 
+interface GeneratedOutputState {
+  outputPath: string;
+  clientClassName: string;
+}
+
 // This method is called when your extension is activated
 // Your extension is activated the very first time the command is executed
 export async function activate(
@@ -46,13 +51,12 @@ export async function activate(
   kiotaOutputChannel = vscode.window.createOutputChannel("Kiota", {
     log: true,
   });
-  const workspaceJsonPath = path.join(vscode.workspace.workspaceFolders?.map(folder => folder.uri.fsPath).join('') || '', KIOTA_DIRECTORY, KIOTA_WORKSPACE_FILE);
   const openApiTreeProvider = new OpenApiTreeProvider(context, () => getExtensionSettings(extensionId));
   const dependenciesInfoProvider = new DependenciesViewProvider(
     context.extensionUri
   );
   const reporter = new TelemetryReporter(context.extension.packageJSON.telemetryInstrumentationKey);
-  new KiotaWorkspace(context);
+  await loadTreeView(context);
   let codeLensProvider = new CodeLensProvider();
   context.subscriptions.push(
     vscode.window.registerUriHandler({
@@ -127,15 +131,7 @@ export async function activate(
           );
           return;
         }
-        if (
-          !vscode.workspace.workspaceFolders ||
-          vscode.workspace.workspaceFolders.length === 0
-        ) {
-          await vscode.window.showErrorMessage(
-            vscode.l10n.t("No workspace folder found, open a folder first")
-          );
-          return;
-        }
+
         let languagesInformation = await getLanguageInformation(context);
         config = await generateSteps(
           {
@@ -157,27 +153,50 @@ export async function activate(
           );
           return;
         }
-        
+
         const settings = getExtensionSettings(extensionId);
         workspaceGenerationType = config.generationType as string;
+        let result;
         switch (generationType) {
           case GenerationType.Client:
-            await generateClientAndRefreshUI(config, settings, outputPath, selectedPaths);
-          break;
+            result = await generateClientAndRefreshUI(config, settings, outputPath, selectedPaths);
+            break;
           case GenerationType.Plugin:
-            await generatePluginAndRefreshUI(config, settings, outputPath, selectedPaths);
-          break;
+            result = await generatePluginAndRefreshUI(config, settings, outputPath, selectedPaths);
+            break;
           case GenerationType.ApiManifest:
-            await generateManifestAndRefreshUI(config, settings, outputPath, selectedPaths);
-          break;
+            result = await generateManifestAndRefreshUI(config, settings, outputPath, selectedPaths);
+            break;
           default:
             await vscode.window.showErrorMessage(
               vscode.l10n.t("Invalid generation type")
             );
-          break;
+            return;
+        }
+        if (result && getLogEntriesForLevel(result, LogLevel.critical, LogLevel.error).length === 0) {
+          // Save state before opening the new window
+          void context.workspaceState.update('generatedOutput', {
+            outputPath,
+            config,
+            clientClassName: config.clientClassName || config.pluginName
+          } as GeneratedOutputState);
+          if (!vscode.workspace.workspaceFolders || vscode.workspace.workspaceFolders.length === 0) {
+            await vscode.commands.executeCommand('vscode.openFolder', vscode.Uri.file(outputPath), true);
+          } else {
+            await displayGenerationResults(context, openApiTreeProvider, config, outputPath);
+          }
         }
       }
     ),
+    vscode.workspace.onDidChangeWorkspaceFolders(async () => {
+      const generatedOutput = context.workspaceState.get<GeneratedOutputState>('generatedOutput');
+      if (generatedOutput) {
+        const { outputPath} = generatedOutput;
+        await displayGenerationResults(context, openApiTreeProvider, config, outputPath);
+        // Clear the state 
+        void context.workspaceState.update('generatedOutput', undefined);
+      }
+    }),
     registerCommandWithTelemetry(reporter, 
       `${treeViewId}.searchOrOpenApiDescription`,
       async () => {
@@ -276,7 +295,7 @@ export async function activate(
     }),
   );
 
-  async function generateManifestAndRefreshUI(config: Partial<GenerateState>, settings: ExtensionSettings, outputPath: string, selectedPaths: string[]):Promise<void> {
+  async function generateManifestAndRefreshUI(config: Partial<GenerateState>, settings: ExtensionSettings, outputPath: string, selectedPaths: string[]):Promise<KiotaLogEntry[]| undefined> {
     const pluginTypes = KiotaPluginType.ApiManifest;
     const result = await vscode.window.withProgress({
       location: vscode.ProgressLocation.Notification,
@@ -311,15 +330,11 @@ export async function activate(
     });
     if (result)
     {
-      await checkForSuccess(result);
-      openApiTreeProvider.refreshView();
-      openApiTreeProvider.setSelectionChanged(false);
-      await loadLockFile({fsPath: workspaceJsonPath}, openApiTreeProvider, config.pluginName);
-      await updateTreeViewIcons(treeViewId, false, true);
       await exportLogsAndShowErrors(result);
     }
+    return result;
   }
-  async function generatePluginAndRefreshUI(config: Partial<GenerateState>, settings: ExtensionSettings, outputPath: string, selectedPaths: string[]):Promise<void> {
+  async function generatePluginAndRefreshUI(config: Partial<GenerateState>, settings: ExtensionSettings, outputPath: string, selectedPaths: string[]):Promise<KiotaLogEntry[] | undefined> {
     const pluginTypes = Array.isArray(config.pluginTypes) ? parsePluginType(config.pluginTypes) : [KiotaPluginType.ApiPlugin];
     const result = await vscode.window.withProgress({
       location: vscode.ProgressLocation.Notification,
@@ -354,15 +369,11 @@ export async function activate(
     });
     if (result)
     {
-      await checkForSuccess(result);
-      openApiTreeProvider.refreshView();
-      openApiTreeProvider.setSelectionChanged(false);
-      await loadLockFile({fsPath: workspaceJsonPath}, openApiTreeProvider, config.pluginName);
-      await updateTreeViewIcons(treeViewId, false, true);
       await exportLogsAndShowErrors(result);
     }
+    return result;
   }
-  async function generateClientAndRefreshUI(config: Partial<GenerateState>, settings: ExtensionSettings, outputPath: string, selectedPaths: string[]):Promise<void> {
+  async function generateClientAndRefreshUI(config: Partial<GenerateState>, settings: ExtensionSettings, outputPath: string, selectedPaths: string[]):Promise<KiotaLogEntry[] | undefined> {
     const language =
           typeof config.language === "string"
             ? parseGenerationLanguage(config.language)
@@ -417,22 +428,20 @@ export async function activate(
       dependenciesInfoProvider.update(languagesInformation, language);
       await vscode.commands.executeCommand(treeViewFocusCommand);
     }
-    if (typeof config.outputPath === "string" && !openApiTreeProvider.isLockFileLoaded && 
-        vscode.workspace.workspaceFolders && vscode.workspace.workspaceFolders.length > 0 &&
-        result && getLogEntriesForLevel(result, LogLevel.critical, LogLevel.error).length === 0) {
-          const WORKSPACE_FOLDER = vscode.workspace.workspaceFolders[0].uri.fsPath;
-          const KIOTA_WORKSPACE_PATH = path.join(WORKSPACE_FOLDER, KIOTA_DIRECTORY, KIOTA_WORKSPACE_FILE);
-          await openApiTreeProvider.loadLockFile(KIOTA_WORKSPACE_PATH, config.clientClassName);
-        }
     if (result)
     {
-      await checkForSuccess(result);
-      openApiTreeProvider.refreshView();
-      openApiTreeProvider.setSelectionChanged(false);
-      await loadLockFile({fsPath: workspaceJsonPath}, openApiTreeProvider, config.clientClassName);
-      await updateTreeViewIcons(treeViewId, false, true);
       await exportLogsAndShowErrors(result);
     }
+    return result;
+  }
+
+  async function displayGenerationResults(context: vscode.ExtensionContext, openApiTreeProvider: OpenApiTreeProvider, config: any, outputPath: string) {
+    const clientNameOrPluginName = config.clientClassName || config.pluginName;
+    openApiTreeProvider.refreshView();
+    openApiTreeProvider.setSelectionChanged(false);
+    const workspaceJsonPath = path.join(vscode.workspace.workspaceFolders?.map(folder => folder.uri.fsPath).join('') || '', KIOTA_DIRECTORY, KIOTA_WORKSPACE_FILE);
+    await loadLockFile({fsPath: workspaceJsonPath}, openApiTreeProvider, clientNameOrPluginName );
+    await updateTreeViewIcons(treeViewId, false, true);
   }
   async function regenerateClient(clientKey: string, clientObject:any, settings: ExtensionSettings,  selectedPaths?: string[]): Promise<void> {
     const language =

vscode/microsoft-kiota/src/kiotaInterop.ts

@@ -2,12 +2,13 @@ import * as vscode from "vscode";
 import * as cp from 'child_process';
 import * as rpc from 'vscode-jsonrpc/node';
 import { ensureKiotaIsPresent, getKiotaPath } from './kiotaInstall';
+import { getWorkspaceJsonDirectory } from "./util";
 
 export async function connectToKiota<T>(context: vscode.ExtensionContext, callback:(connection: rpc.MessageConnection) => Promise<T | undefined>): Promise<T | undefined> {
   const kiotaPath = getKiotaPath(context);
   await ensureKiotaIsPresent(context);
   const childProcess = cp.spawn(kiotaPath, ["rpc"],{
-    cwd: vscode.workspace.workspaceFolders && vscode.workspace.workspaceFolders.length > 0 ? vscode.workspace.workspaceFolders[0].uri.fsPath : undefined,
+    cwd: getWorkspaceJsonDirectory(),
     env: {
         ...process.env,
         // eslint-disable-next-line @typescript-eslint/naming-convention

vscode/microsoft-kiota/src/steps.ts

@@ -1,6 +1,6 @@
 import { QuickPickItem, window, Disposable, QuickInputButton, QuickInput, QuickInputButtons, workspace, l10n, Uri, OpenDialogOptions } from 'vscode';
 import { allGenerationLanguages, generationLanguageToString, KiotaSearchResultItem, LanguagesInformation, maturityLevelToString } from './kiotaInterop';
-import * as vscode from 'vscode';
+import { findAppPackageDirectory, getWorkspaceJsonDirectory } from './util';
 
 export async function filterSteps(existingFilter: string, filterCallback: (searchQuery: string) => void) {
     const state = {} as Partial<BaseStepsState>;
@@ -107,9 +107,14 @@ export async function generateSteps(existingConfiguration: Partial<GenerateState
 
     if(typeof state.outputPath === 'string') {
         state.outputPath = workspace.asRelativePath(state.outputPath);
-        }
-    const workspaceFolder = vscode.workspace.workspaceFolders?.[0].uri.fsPath || '';
-
+    }
+
+    let workspaceFolder = getWorkspaceJsonDirectory();
+    const appPackagePath = findAppPackageDirectory(workspaceFolder);
+    if (appPackagePath) {
+      workspaceFolder = appPackagePath;
+    }
+
     let step = 1;
     let totalSteps = 4;
 

vscode/microsoft-kiota/src/util.ts

@@ -1,5 +1,7 @@
 import * as vscode from 'vscode';
-import { APIMANIFEST, CLIENT, CLIENTS, PLUGIN, PLUGINS } from './constants';
+import * as path from 'path';
+import * as fs from 'fs';
+import { APIMANIFEST, CLIENT, CLIENTS, KIOTA_DIRECTORY, KIOTA_WORKSPACE_FILE, PLUGIN, PLUGINS } from './constants';
 
 const clientTypes = [CLIENT, CLIENTS];
 const pluginTypes = [PLUGIN, PLUGINS, APIMANIFEST];
@@ -17,4 +19,50 @@ export async function updateTreeViewIcons(treeViewId: string, showIcons: boolean
     if (showRegenerateIcon !== undefined) {
         await vscode.commands.executeCommand('setContext', `${treeViewId}.showRegenerateIcon`, showRegenerateIcon);
     }
+}
+
+export function getWorkspaceJsonPath(): string {
+    return path.join(getWorkspaceJsonDirectory(),KIOTA_DIRECTORY, KIOTA_WORKSPACE_FILE);
+};
+
+export function getWorkspaceJsonDirectory(): string {
+  const baseDir = path.join(
+    vscode.workspace.workspaceFolders && vscode.workspace.workspaceFolders.length > 0
+      ? vscode.workspace.workspaceFolders[0].uri.fsPath
+      : process.env.HOME ?? process.env.USERPROFILE ?? process.cwd()
+  );
+
+  let workspaceFolder = !vscode.workspace.workspaceFolders || vscode.workspace.workspaceFolders.length === 0
+    ? path.join(baseDir, 'kiota')
+    : baseDir;
+
+if (!fs.existsSync(workspaceFolder)) {
+    fs.mkdirSync(workspaceFolder, { recursive: true });
+  }
+  return workspaceFolder;
+}
+
+export function findAppPackageDirectory(directory: string): string | null {
+  if (!fs.existsSync(directory)) {
+    return null;
+  }
+
+  const entries = fs.readdirSync(directory, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(directory, entry.name);
+
+    if (entry.isDirectory()) {
+      if (entry.name === 'appPackage') {
+        return fullPath;
+      }
+
+      const subDirectory = findAppPackageDirectory(fullPath);
+      if (subDirectory) {
+        return subDirectory;
+      }
+    }
+  }
+
+  return null;
 }

vscode/microsoft-kiota/src/workspaceTreeProvider.ts

@@ -1,61 +1,58 @@
 import * as vscode from 'vscode';
 import * as path from 'path';
 import * as fs from 'fs';
-import { KIOTA_DIRECTORY, KIOTA_WORKSPACE_FILE } from './constants';
+import { KIOTA_WORKSPACE_FILE } from './constants';
+import { getWorkspaceJsonPath } from './util';
 
-const workspaceJsonPath = path.join(vscode.workspace.workspaceFolders?.map(folder => folder.uri.fsPath).join('') || '', KIOTA_DIRECTORY, KIOTA_WORKSPACE_FILE);
 
 export class WorkspaceTreeProvider implements vscode.TreeDataProvider<vscode.TreeItem> {
-
-    constructor(private context: vscode.ExtensionContext) {
-        void this.ensureKiotaDirectory();
+    constructor(public isWSPresent: boolean) {
     }
     async getChildren(element?: vscode.TreeItem): Promise<vscode.TreeItem[]> {
-        if (!element) {
-            return [new vscode.TreeItem(KIOTA_WORKSPACE_FILE, vscode.TreeItemCollapsibleState.None)];
-        }
+      if (!this.isWSPresent) {
         return [];
+      }
+      if (!element) {
+        return [new vscode.TreeItem(KIOTA_WORKSPACE_FILE, vscode.TreeItemCollapsibleState.None)];
+      }
+      return [];
     }
 
     getTreeItem(element: vscode.TreeItem): vscode.TreeItem {
         if (element) {
-            element.command = { command: 'kiota.workspace.openWorkspaceFile', title: vscode.l10n.t("Open File"), arguments: [vscode.Uri.file(workspaceJsonPath)], };
+            element.command = {
+              command: 'kiota.workspace.openWorkspaceFile', 
+              title: vscode.l10n.t("Open File"), 
+              arguments: [vscode.Uri.file(getWorkspaceJsonPath())] 
+            };
             element.contextValue = 'file';
         }
         return element;
     }
+}
 
-    private async ensureKiotaDirectory(): Promise<unknown> {
-        if (!vscode.workspace.workspaceFolders || vscode.workspace.workspaceFolders.length === 0) {
-            await vscode.window.showErrorMessage(
-                vscode.l10n.t("No workspace folder found, open a folder first")
-            );
-            return;
-        }
-        const kiotaDir = path.dirname(workspaceJsonPath);
-        try {
-            await fs.promises.access(kiotaDir);
-        } catch (error) {
-            await vscode.window.showErrorMessage(
-                vscode.l10n.t("Kiota directory not found")
-            );
-        }
+async function openResource(resource: vscode.Uri): Promise<void> {
+        await vscode.window.showTextDocument(resource);
+}
+async function isKiotaWorkspaceFilePresent(): Promise<boolean> {
+    const workspaceFileDir = path.resolve(getWorkspaceJsonPath());
+    try {
+        await fs.promises.access(workspaceFileDir);
+    } catch (error) {
+        return false;
     }
+    return true;
 }
 
-export class KiotaWorkspace {
-    constructor(context: vscode.ExtensionContext) {
-        const treeDataProvider = new WorkspaceTreeProvider(context);
-        context.subscriptions.push(vscode.window.createTreeView('kiota.workspace', { treeDataProvider }));
-        vscode.commands.registerCommand('kiota.workspace.openWorkspaceFile', async (resource) => await this.openResource(resource));
-    }
-    private async openResource(resource: vscode.Uri): Promise<void> {
-        try{
-            await vscode.window.showTextDocument(resource);
-        } catch (error) {
-            await fs.promises.writeFile(workspaceJsonPath, Buffer.from('{}'));
-            await vscode.window.showTextDocument(resource);
-        }
-
-    }
-}
+export async function loadTreeView(context: vscode.ExtensionContext): Promise<void> {
+    const treeDataProvider = new WorkspaceTreeProvider(await isKiotaWorkspaceFilePresent());
+    context.subscriptions.push(vscode.workspace.onDidChangeWorkspaceFolders(async () => {
+      treeDataProvider.isWSPresent = await isKiotaWorkspaceFilePresent();
+      await vscode.commands.executeCommand('kiota.workspace.refresh'); // Refresh the tree view when workspace folders change
+  }));
+    context.subscriptions.push(vscode.window.createTreeView('kiota.workspace', { treeDataProvider }));
+    context.subscriptions.push(vscode.commands.registerCommand('kiota.workspace.openWorkspaceFile', openResource));
+    context.subscriptions.push(vscode.commands.registerCommand('kiota.workspace.refresh', async () => { 
+      treeDataProvider.isWSPresent = await isKiotaWorkspaceFilePresent();
+    }));
+}