diff --git a/scripts/copyassets.js b/scripts/copyassets.js
index 70ba026b..28fc638b 100644
--- a/scripts/copyassets.js
+++ b/scripts/copyassets.js
@@ -61,6 +61,10 @@ function copyAssests() {
     path.join(srcDir, 'assets', 'jupyterlab-wordmark.svg'),
     path.join(dest, '../app-assets', 'jupyterlab-wordmark.svg')
   );
+  fs.copySync(
+    path.join(srcDir, 'assets', 'copyable-span.js'),
+    path.join(dest, '../app-assets', 'copyable-span.js')
+  );
 
   const toolkitPath = path.join(
     '../node_modules',
diff --git a/src/assets/copyable-span.js b/src/assets/copyable-span.js
new file mode 100644
index 00000000..17c62399
--- /dev/null
+++ b/src/assets/copyable-span.js
@@ -0,0 +1,70 @@
+const template = document.createElement('template');
+template.innerHTML = `
+  <style>
+    .container {
+      display: flex;
+      gap: 5px;
+      width: fit-content;
+      padding: 2px;
+      background: var(--neutral-layer-2);
+      cursor: pointer;
+    }
+    .container:hover, .container:hover svg {
+      color: var(--neutral-foreground-hint);
+      fill: var(--neutral-foreground-hint);
+    }
+    .container:active, .container:active svg {
+      color: var(--accent-foreground-active);
+      fill: var(--accent-foreground-active);
+    }
+    .copy-icon svg {
+      fill: var(--neutral-foreground-rest);
+      width: 16px;
+      height: 16px;
+    }
+  </style>
+  <div style="display: inline-block;">
+    <div class="container" data-copied="" title="Copy to clipboard">
+        <div class="label"></div><div class="copy-icon"><svg xmlns="http://www.w3.org/2000/svg" height="1em" viewBox="0 0 448 512"><!--! Font Awesome Free 6.4.2 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2023 Fonticons, Inc. --><path d="M384 336H192c-8.8 0-16-7.2-16-16V64c0-8.8 7.2-16 16-16l140.1 0L400 115.9V320c0 8.8-7.2 16-16 16zM192 384H384c35.3 0 64-28.7 64-64V115.9c0-12.7-5.1-24.9-14.1-33.9L366.1 14.1c-9-9-21.2-14.1-33.9-14.1H192c-35.3 0-64 28.7-64 64V320c0 35.3 28.7 64 64 64zM64 128c-35.3 0-64 28.7-64 64V448c0 35.3 28.7 64 64 64H256c35.3 0 64-28.7 64-64V416H272v32c0 8.8-7.2 16-16 16H64c-8.8 0-16-7.2-16-16V192c0-8.8 7.2-16 16-16H96V128H64z"/></svg></div>
+    </div>
+  </div>
+`;
+
+class CopyableSpan extends HTMLElement {
+  constructor() {
+    super();
+
+    this.attachShadow({ mode: 'open' });
+
+    this.shadowRoot.appendChild(template.content.cloneNode(true));
+    this.shadowRoot.querySelector('.container').onclick = evt => {
+      window.electronAPI.copyToClipboard(evt.currentTarget.dataset.copied);
+    };
+  }
+
+  static get observedAttributes() {
+    return ['label', 'title', 'copied'];
+  }
+
+  attributeChangedCallback(name, oldValue, newValue) {
+    switch (name) {
+      case 'label':
+        this.shadowRoot.querySelector('.label').innerText = decodeURIComponent(
+          newValue
+        );
+        break;
+      case 'title':
+        this.shadowRoot.querySelector('.container').title = decodeURIComponent(
+          newValue
+        );
+        break;
+      case 'copied':
+        this.shadowRoot.querySelector(
+          '.container'
+        ).dataset.copied = decodeURIComponent(newValue);
+        break;
+    }
+  }
+}
+
+window.customElements.define('copyable-span', CopyableSpan);
diff --git a/src/main/cli.ts b/src/main/cli.ts
index b0728e99..08423c6a 100644
--- a/src/main/cli.ts
+++ b/src/main/cli.ts
@@ -449,22 +449,36 @@ export async function runCommandInEnvironment(
     ' && '
   );
 
+  // TODO: implement timeout. in case there is network issues
+
   return new Promise<boolean>((resolve, reject) => {
     const shell = isWin
       ? spawn('cmd', ['/c', commandScript], {
-          env: process.env
+          env: process.env,
+          windowsVerbatimArguments: true
         })
       : spawn('bash', ['-c', commandScript], {
-          stdio: 'inherit',
           env: {
             ...process.env,
             BASH_SILENCE_DEPRECATION_WARNING: '1'
           }
         });
 
+    if (shell.stdout) {
+      shell.stdout.on('data', chunk => {
+        console.debug('>', Buffer.from(chunk).toString());
+      });
+    }
+    if (shell.stderr) {
+      shell.stderr.on('data', chunk => {
+        console.error('>', Buffer.from(chunk).toString());
+      });
+    }
+
     shell.on('close', code => {
       if (code !== 0) {
         console.error('Shell exit with code:', code);
+        resolve(false);
       }
       resolve(true);
     });
diff --git a/src/main/eventtypes.ts b/src/main/eventtypes.ts
index a05dedc5..5f39aa51 100644
--- a/src/main/eventtypes.ts
+++ b/src/main/eventtypes.ts
@@ -55,7 +55,10 @@ export enum EventTypeMain {
   SetServerLaunchArgs = 'set-server-launch-args',
   SetServerEnvVars = 'set-server-env-vars',
   SetCtrlWBehavior = 'set-ctrl-w-behavior',
-  SetAuthDialogResponse = 'set-auth-dialog-response'
+  SetAuthDialogResponse = 'set-auth-dialog-response',
+  InstallPythonEnvRequirements = 'install-python-env-requirements',
+  ShowLogs = 'show-logs',
+  CopyToClipboard = 'copy-to-clipboard'
 }
 
 // events sent to Renderer process
diff --git a/src/main/progressview/preload.ts b/src/main/progressview/preload.ts
index 21deea5d..727b6978 100644
--- a/src/main/progressview/preload.ts
+++ b/src/main/progressview/preload.ts
@@ -34,6 +34,9 @@ contextBridge.exposeInMainWorld('electronAPI', {
     callback: InstallBundledPythonEnvStatusListener
   ) => {
     onInstallBundledPythonEnvStatusListener = callback;
+  },
+  copyToClipboard: (content: string) => {
+    ipcRenderer.send(EventTypeMain.CopyToClipboard, content);
   }
 });
 
diff --git a/src/main/progressview/progressview.ts b/src/main/progressview/progressview.ts
index 465dfb2f..053e015e 100644
--- a/src/main/progressview/progressview.ts
+++ b/src/main/progressview/progressview.ts
@@ -17,6 +17,9 @@ export class ProgressView {
     const progressLogo = fs.readFileSync(
       path.join(__dirname, '../../../app-assets/progress-logo.svg')
     );
+    const copyableSpanSrc = fs.readFileSync(
+      path.join(__dirname, '../../../app-assets/copyable-span.js')
+    );
 
     const template = `
       <style>
@@ -79,6 +82,7 @@ export class ProgressView {
         </div>
       </div>
 
+      <script>${copyableSpanSrc}</script>
       <script>
       const progressSvg = document.querySelector('#progress-logo svg');
       const progressTitle = document.getElementById('progress-title');
diff --git a/src/main/registry.ts b/src/main/registry.ts
index f974338e..e0dc4b6a 100644
--- a/src/main/registry.ts
+++ b/src/main/registry.ts
@@ -12,7 +12,9 @@ import {
   IDisposable,
   IEnvironmentType,
   IPythonEnvironment,
-  IVersionContainer
+  IPythonEnvResolveError,
+  IVersionContainer,
+  PythonEnvResolveErrorType
 } from './tokens';
 import {
   envPathForPythonPath,
@@ -21,6 +23,7 @@ import {
   getEnvironmentPath,
   getUserHomeDir,
   isBaseCondaEnv,
+  isCondaEnv,
   isPortInUse,
   pythonPathForEnvPath,
   versionWithoutSuffix
@@ -45,6 +48,7 @@ export interface IRegistry {
   getCurrentPythonEnvironment: () => IPythonEnvironment;
   getAdditionalPathIncludesForPythonPath: (pythonPath: string) => string;
   getRequirements: () => Registry.IRequirement[];
+  getRequirementsInstallCommand: (envPath: string) => string;
   getEnvironmentInfo(pythonPath: string): Promise<IPythonEnvironment>;
   getRunningServerList(): Promise<string[]>;
   dispose(): Promise<void>;
@@ -53,17 +57,18 @@ export interface IRegistry {
 }
 
 export const SERVER_TOKEN_PREFIX = 'jlab:srvr:';
+const MIN_JLAB_VERSION_REQUIRED = '3.0.0';
 
 export class Registry implements IRegistry, IDisposable {
   constructor() {
-    const minJLabVersionRequired = '3.0.0';
-
     this._requirements = [
       {
         name: 'jupyterlab',
         moduleName: 'jupyterlab',
         commands: ['--version'],
-        versionRange: new semver.Range(`>=${minJLabVersionRequired}`)
+        versionRange: new semver.Range(`>=${MIN_JLAB_VERSION_REQUIRED}`),
+        pipCommand: `"jupyterlab>=${MIN_JLAB_VERSION_REQUIRED}"`,
+        condaCommand: `"jupyterlab>=${MIN_JLAB_VERSION_REQUIRED}"`
       }
     ];
 
@@ -78,18 +83,22 @@ export class Registry implements IRegistry, IDisposable {
       pythonPath = getBundledPythonPath();
     }
 
-    const defaultEnv = this._resolveEnvironmentSync(pythonPath);
-
-    if (defaultEnv) {
-      this._defaultEnv = defaultEnv;
-      if (
-        defaultEnv.type === IEnvironmentType.CondaRoot &&
-        !this._condaRootPath
-      ) {
-        // this call overrides user set appData.condaRootPath
-        // which is probably better for compatibility
-        this.setCondaRootPath(getEnvironmentPath(defaultEnv));
+    try {
+      const defaultEnv = this._resolveEnvironmentSync(pythonPath);
+
+      if (defaultEnv) {
+        this._defaultEnv = defaultEnv;
+        if (
+          defaultEnv.type === IEnvironmentType.CondaRoot &&
+          !this._condaRootPath
+        ) {
+          // this call overrides user set appData.condaRootPath
+          // which is probably better for compatibility
+          this.setCondaRootPath(getEnvironmentPath(defaultEnv));
+        }
       }
+    } catch (error) {
+      //
     }
 
     if (!this._condaRootPath && appData.condaRootPath) {
@@ -99,9 +108,13 @@ export class Registry implements IRegistry, IDisposable {
         // set default env from appData.condaRootPath
         if (!this._defaultEnv) {
           const pythonPath = pythonPathForEnvPath(appData.condaRootPath, true);
-          const defaultEnv = this._resolveEnvironmentSync(pythonPath);
-          if (defaultEnv) {
-            this._defaultEnv = defaultEnv;
+          try {
+            const defaultEnv = this._resolveEnvironmentSync(pythonPath);
+            if (defaultEnv) {
+              this._defaultEnv = defaultEnv;
+            }
+          } catch (error) {
+            //
           }
         }
       }
@@ -222,17 +235,46 @@ export class Registry implements IRegistry, IDisposable {
 
   private _resolveEnvironmentSync(pythonPath: string): IPythonEnvironment {
     if (!this._pathExistsSync(pythonPath)) {
-      return;
+      log.error(`Python path "${pythonPath}" does not exist.`);
+      throw {
+        type: PythonEnvResolveErrorType.PathNotFound
+      } as IPythonEnvResolveError;
     }
 
-    const env = this.getEnvironmentInfoSync(pythonPath);
+    let env: IPythonEnvironment;
 
-    if (
-      env &&
-      this._environmentSatisfiesRequirements(env, this._requirements)
-    ) {
-      return env;
+    try {
+      env = this.getEnvironmentInfoSync(pythonPath);
+    } catch (error) {
+      log.error(
+        `Failed to get environment info at path '${pythonPath}'.`,
+        error
+      );
+      throw {
+        type: PythonEnvResolveErrorType.ResolveError
+      } as IPythonEnvResolveError;
+    }
+
+    if (!this._environmentSatisfiesRequirements(env, this._requirements)) {
+      const envPath = envPathForPythonPath(pythonPath);
+      const versionsFound: string[] = [];
+      this._requirements.forEach(req => {
+        versionsFound.push(`${req.name}: ${env.versions[req.name]}`);
+      });
+
+      log.error(
+        `Required Python packages not found in the environment path "${envPath}". Versions found are: ${versionsFound.join(
+          ','
+        )}. You can install missing packages using '${this.getRequirementsInstallCommand(
+          envPath
+        )}'.`
+      );
+      throw {
+        type: PythonEnvResolveErrorType.RequirementsNotSatisfied
+      } as IPythonEnvResolveError;
     }
+
+    return env;
   }
 
   /**
@@ -330,22 +372,14 @@ export class Registry implements IRegistry, IDisposable {
       return inUserSetEnvList;
     }
 
-    try {
-      const env = this._resolveEnvironmentSync(pythonPath);
-      if (env) {
-        this._userSetEnvironments.push(env);
-        this._updateEnvironments();
-        this._environmentListUpdated.emit();
-      }
-
-      return env;
-    } catch (error) {
-      console.error(
-        `Failed to add the Python environment at: ${pythonPath}`,
-        error
-      );
-      return;
+    const env = this._resolveEnvironmentSync(pythonPath);
+    if (env) {
+      this._userSetEnvironments.push(env);
+      this._updateEnvironments();
+      this._environmentListUpdated.emit();
     }
+
+    return env;
   }
 
   validatePythonEnvironmentAtPath(pythonPath: string): boolean {
@@ -386,7 +420,7 @@ export class Registry implements IRegistry, IDisposable {
         defaultKernel: envInfo.defaultKernel
       };
     } catch (error) {
-      console.error(
+      log.error(
         `Failed to get environment info at path '${pythonPath}'.`,
         error
       );
@@ -446,6 +480,19 @@ export class Registry implements IRegistry, IDisposable {
     return this._requirements;
   }
 
+  getRequirementsInstallCommand(envPath: string): string {
+    const isConda = isCondaEnv(envPath);
+    const cmdList = [
+      isConda ? 'conda install -c conda-forge -y' : 'pip install'
+    ];
+
+    this._requirements.forEach(req => {
+      cmdList.push(isConda ? req.condaCommand : req.pipCommand);
+    });
+
+    return cmdList.join(' ');
+  }
+
   getRunningServerList(): Promise<string[]> {
     return new Promise<string[]>(resolve => {
       if (this._defaultEnv) {
@@ -886,21 +933,6 @@ export class Registry implements IRegistry, IDisposable {
     });
   }
 
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore
-  private _runPythonModuleCommandSync(
-    pythonPath: string,
-    moduleName: string,
-    commands: string[]
-  ): string {
-    const totalCommands = ['-m', moduleName].concat(commands);
-    const runOptions = {
-      env: { PATH: this.getAdditionalPathIncludesForPythonPath(pythonPath) }
-    };
-
-    return this._runCommandSync(pythonPath, totalCommands, runOptions);
-  }
-
   private async _runCommand(
     executablePath: string,
     commands: string[],
@@ -971,11 +1003,7 @@ export class Registry implements IRegistry, IDisposable {
     commands: string[],
     options?: ExecFileOptions
   ): string {
-    try {
-      return execFileSync(executablePath, commands, options).toString();
-    } catch (error) {
-      return 'EXEC:ERROR';
-    }
+    return execFileSync(executablePath, commands, options).toString();
   }
 
   private _sortEnvironments(
@@ -1116,6 +1144,15 @@ export namespace Registry {
      * The Range of acceptable version produced by the previous commands field
      */
     versionRange: semver.Range;
+
+    /**
+     * pip install command
+     */
+    pipCommand: string;
+    /**
+     * conda install command
+     */
+    condaCommand: string;
   }
 
   export const COMMON_CONDA_LOCATIONS = [
diff --git a/src/main/sessionwindow/sessionwindow.ts b/src/main/sessionwindow/sessionwindow.ts
index 80587d2c..dc050dbc 100644
--- a/src/main/sessionwindow/sessionwindow.ts
+++ b/src/main/sessionwindow/sessionwindow.ts
@@ -4,6 +4,7 @@
 import {
   BrowserView,
   BrowserWindow,
+  clipboard,
   dialog,
   Menu,
   MenuItemConstructorOptions,
@@ -22,7 +23,9 @@ import { TitleBarView } from '../titlebarview/titlebarview';
 import {
   clearSession,
   DarkThemeBGColor,
+  envPathForPythonPath,
   getBundledPythonPath,
+  getLogFilePath,
   isDarkTheme,
   LightThemeBGColor
 } from '../utils';
@@ -31,7 +34,8 @@ import {
   IDisposable,
   IPythonEnvironment,
   IRect,
-  IVersionContainer
+  IVersionContainer,
+  PythonEnvResolveErrorType
 } from '../tokens';
 import { IRegistry } from '../registry';
 import { IApplication } from '../app';
@@ -44,6 +48,7 @@ import { SessionConfig } from '../config/sessionconfig';
 import { ISignal, Signal } from '@lumino/signaling';
 import { EventTypeMain } from '../eventtypes';
 import { EventManager } from '../eventmanager';
+import { runCommandInEnvironment } from '../cli';
 
 export enum ContentViewType {
   Welcome = 'welcome',
@@ -667,6 +672,81 @@ export class SessionWindow implements IDisposable {
       }
     );
 
+    this._evm.registerEventHandler(
+      EventTypeMain.InstallPythonEnvRequirements,
+      (
+        event,
+        pythonPath: string,
+        postInstallAction: 'none' | 'restart-server' = 'none'
+      ) => {
+        if (event.sender !== this._progressView?.view?.view?.webContents) {
+          return;
+        }
+
+        pythonPath = decodeURIComponent(pythonPath);
+        // prevent injections by checking if the path is really file
+        const stat = fs.lstatSync(pythonPath);
+        if (!(stat && (stat.isFile() || stat.isSymbolicLink()))) {
+          console.error(
+            'InstallPythonEnvRequirements called with invalid Python path.'
+          );
+          return;
+        }
+
+        const envPath = envPathForPythonPath(pythonPath);
+        const installCommand = this._registry.getRequirementsInstallCommand(
+          envPath
+        );
+
+        this._showProgressView('Installing required packages');
+
+        runCommandInEnvironment(envPath, installCommand).then(result => {
+          if (result) {
+            this._showProgressView(
+              'Finished installing packages',
+              postInstallAction === 'restart-server'
+                ? '<div class="message-row">Restarting the server now...</div>'
+                : ''
+            );
+            try {
+              this._registry.addEnvironment(pythonPath);
+              if (postInstallAction === 'restart-server') {
+                this._restartServerInPythonEnvironment(pythonPath);
+              } else {
+                this._showProgressView(
+                  'Finished installing required packages',
+                  `<div class="message-row"><a href="javascript:void(0);" onclick="sendMessageToMain('${EventTypeMain.ShowWelcomeView}')">Go to Welcome Page</a></div>`
+                );
+              }
+            } catch (error) {
+              this._showProgressView(
+                'Failed to update the environment',
+                `<div class="message-row"><a href="javascript:void(0);" onclick="sendMessageToMain('${EventTypeMain.ShowLogs}')">Show logs</a></div>
+                <div class="message-row"><a href="javascript:void(0);" onclick="sendMessageToMain('${EventTypeMain.HideProgressView}')">Close</a></div>`
+              );
+            }
+          } else {
+            this._showProgressView(
+              'Failed to install required packages',
+              `<div class="message-row"><a href="javascript:void(0);" onclick="sendMessageToMain('${EventTypeMain.ShowLogs}')">Show logs</a></div>
+              <div class="message-row"><a href="javascript:void(0);" onclick="sendMessageToMain('${EventTypeMain.HideProgressView}')">Close</a></div>`
+            );
+          }
+        });
+      }
+    );
+
+    this._evm.registerEventHandler(EventTypeMain.ShowLogs, event => {
+      shell.openPath(getLogFilePath());
+    });
+
+    this._evm.registerEventHandler(
+      EventTypeMain.CopyToClipboard,
+      (event, content) => {
+        clipboard.writeText(content);
+      }
+    );
+
     this._evm.registerEventHandler(
       EventTypeMain.OpenDroppedFiles,
       (event, fileOrFolders: string[]) => {
@@ -712,40 +792,51 @@ export class SessionWindow implements IDisposable {
           'Restarting server using the selected Python enviroment'
         );
 
-        const env = this._registry.addEnvironment(path);
-
-        if (!env) {
+        try {
+          this._registry.addEnvironment(path);
+        } catch (error) {
+          let message = `Error! Python environment at '${path}' is not compatible.`;
+          if (
+            error?.type === PythonEnvResolveErrorType.RequirementsNotSatisfied
+          ) {
+            const envPath = envPathForPythonPath(path);
+            const requirementInstallCmd = encodeURIComponent(
+              this._registry.getRequirementsInstallCommand(envPath)
+            );
+            message = `Error! Required Python packages not found in the selected environment. You can install using <copyable-span label="${requirementInstallCmd}" copied="${requirementInstallCmd}"></copyable-span> command in the selected environment.`;
+          } else if (error?.type === PythonEnvResolveErrorType.PathNotFound) {
+            message = `Error! File not found at '${path}'.`;
+          } else if (error?.type === PythonEnvResolveErrorType.ResolveError) {
+            message = `Error! Failed to get environment information at '${path}'.`;
+          }
           this._showProgressView(
             'Invalid Environment',
-            `<div class="message-row">Error! Python environment at '${path}' is not compatible.</div>
-          <div class="message-row"><a href="javascript:void(0);" onclick="sendMessageToMain('${EventTypeMain.ShowEnvSelectPopup}')">Select another environment</a></div>
-          <div class="message-row"><a href="javascript:void(0);" onclick="sendMessageToMain('${EventTypeMain.HideProgressView}')">Cancel</a></div>`,
+            `<div class="message-row">${message}</div>
+          ${
+            error?.type === PythonEnvResolveErrorType.RequirementsNotSatisfied
+              ? `<div class="message-row"><a href="javascript:void(0);" onclick="sendMessageToMain('${
+                  EventTypeMain.InstallPythonEnvRequirements
+                }', '${encodeURIComponent(
+                  path
+                )}', 'restart-server')">Install the requirements for me and restart the server</a></div>`
+              : ''
+          }
+          <div class="message-row"><a href="javascript:void(0);" onclick="sendMessageToMain('${
+            EventTypeMain.ShowEnvSelectPopup
+          }')">Select another environment</a></div>
+          <div class="message-row"><a href="javascript:void(0);" onclick="sendMessageToMain('${
+            EventTypeMain.ShowLogs
+          }')">Show logs</a></div>
+          <div class="message-row"><a href="javascript:void(0);" onclick="sendMessageToMain('${
+            EventTypeMain.HideProgressView
+          }')">Cancel</a></div>`,
             false
           );
 
           return;
         }
 
-        this._wsSettings.setValue(SettingType.pythonPath, path);
-        this._sessionConfig.pythonPath = path;
-
-        this._disposeSession().then(async () => {
-          try {
-            await this._createServerForSession();
-            this._contentViewType = ContentViewType.Lab;
-            this._updateContentView();
-            this._hideProgressView();
-          } catch (error) {
-            this._setProgress(
-              'Failed to create session',
-              `<div class="message-row">${error}</div>
-            <div class="message-row">
-              <a href="javascript:void(0);" onclick="sendMessageToMain('${EventTypeMain.ShowWelcomeView}')">Go to Welcome Page</a>
-            </div>`,
-              false
-            );
-          }
-        });
+        this._restartServerInPythonEnvironment(path);
       }
     );
 
@@ -859,6 +950,29 @@ export class SessionWindow implements IDisposable {
     );
   }
 
+  private _restartServerInPythonEnvironment(pythonPath: string) {
+    this._wsSettings.setValue(SettingType.pythonPath, pythonPath);
+    this._sessionConfig.pythonPath = pythonPath;
+
+    this._disposeSession().then(async () => {
+      try {
+        await this._createServerForSession();
+        this._contentViewType = ContentViewType.Lab;
+        this._updateContentView();
+        this._hideProgressView();
+      } catch (error) {
+        this._setProgress(
+          'Failed to create session',
+          `<div class="message-row">${error}</div>
+        <div class="message-row">
+          <a href="javascript:void(0);" onclick="sendMessageToMain('${EventTypeMain.ShowWelcomeView}')">Go to Welcome Page</a>
+        </div>`,
+          false
+        );
+      }
+    });
+  }
+
   getPythonEnvironment(): IPythonEnvironment {
     if (this._server?.server) {
       return this._server?.server.info.environment;
@@ -1172,23 +1286,40 @@ export class SessionWindow implements IDisposable {
     pythonPath = this._wsSettings.getValue(SettingType.pythonPath);
 
     if (pythonPath) {
-      const env = this._registry.addEnvironment(pythonPath);
-
-      if (!env) {
-        // reset python path to default
-        this._wsSettings.setValue(SettingType.pythonPath, '');
+      try {
+        this._registry.addEnvironment(pythonPath);
+      } catch (error) {
+        let message = `Error! Python environment at '${pythonPath}' is not compatible.`;
+        if (
+          error?.type === PythonEnvResolveErrorType.RequirementsNotSatisfied
+        ) {
+          const envPath = envPathForPythonPath(pythonPath);
+          const requirementInstallCmd = encodeURIComponent(
+            this._registry.getRequirementsInstallCommand(envPath)
+          );
+          message = `Error! Required packages not found in the Python environment. You can install using <copyable-span label="${requirementInstallCmd}" copied="${requirementInstallCmd}"></copyable-span> command in the selected environment.`;
+        }
 
         this._showProgressView(
           'Invalid Environment configured for project',
-          `<div class="message-row">Error! Python environment at '${pythonPath}' is not compatible.</div>
+          `<div class="message-row">${message}</div>
           ${
-            recentSessionIndex !== undefined
-              ? `<div class="message-row"><a href="javascript:void(0);" onclick="sendMessageToMain('${EventTypeMain.OpenRecentSessionWithDefaultEnv}', ${recentSessionIndex})">Reset to default Python environment</a></div>`
+            error?.type === PythonEnvResolveErrorType.RequirementsNotSatisfied
+              ? `<div class="message-row"><a href="javascript:void(0);" onclick="sendMessageToMain('${
+                  EventTypeMain.InstallPythonEnvRequirements
+                }', '${encodeURIComponent(
+                  pythonPath
+                )}')">Install the requirements for me</a></div>`
               : ''
-          }
-          <div class="message-row"><a href="javascript:void(0);" onclick="sendMessageToMain('${
-            EventTypeMain.HideProgressView
-          }')">Cancel</a></div>`,
+          } 
+        ${
+          recentSessionIndex !== undefined
+            ? `<div class="message-row"><a href="javascript:void(0);" onclick="sendMessageToMain('${EventTypeMain.OpenRecentSessionWithDefaultEnv}', ${recentSessionIndex})">Reset to default Python environment</a></div>`
+            : ''
+        }
+         <div class="message-row"><a href="javascript:void(0);" onclick="sendMessageToMain('${
+           EventTypeMain.HideProgressView
+         }')">Cancel</a></div>`,
           false
         );
 
diff --git a/src/main/settingsdialog/preload.ts b/src/main/settingsdialog/preload.ts
index 9a1136c2..c90b356b 100644
--- a/src/main/settingsdialog/preload.ts
+++ b/src/main/settingsdialog/preload.ts
@@ -31,6 +31,9 @@ contextBridge.exposeInMainWorld('electronAPI', {
   checkForUpdates: () => {
     ipcRenderer.send(EventTypeMain.CheckForUpdates);
   },
+  showLogs: () => {
+    ipcRenderer.send(EventTypeMain.ShowLogs);
+  },
   launchInstallerDownloadPage: () => {
     ipcRenderer.send(EventTypeMain.LaunchInstallerDownloadPage);
   },
diff --git a/src/main/settingsdialog/settingsdialog.ts b/src/main/settingsdialog/settingsdialog.ts
index b806513d..da57ffda 100644
--- a/src/main/settingsdialog/settingsdialog.ts
+++ b/src/main/settingsdialog/settingsdialog.ts
@@ -515,6 +515,7 @@ export class SettingsDialog {
                     <jp-option value="verbose">Verbose</jp-option>
                     <jp-option value="debug">Debug</jp-option>
                   </jp-select>
+                  <jp-button onclick='handleShowLogs(this);'>Show logs</jp-button>
                 </div>
               </div>
 
@@ -551,6 +552,10 @@ export class SettingsDialog {
                   window.electronAPI.checkForUpdates();
                 }
 
+                function handleShowLogs(el) {
+                  window.electronAPI.showLogs();
+                }
+
                 function onLogLevelChanged(el) {
                   window.electronAPI.setLogLevel(el.value);
                 }
diff --git a/src/main/tokens.ts b/src/main/tokens.ts
index b1a456a3..b492eb96 100644
--- a/src/main/tokens.ts
+++ b/src/main/tokens.ts
@@ -64,6 +64,17 @@ export interface IPythonEnvironment {
   defaultKernel: string;
 }
 
+export enum PythonEnvResolveErrorType {
+  PathNotFound = 'path-not-found',
+  ResolveError = 'resolve-error',
+  RequirementsNotSatisfied = 'requirements-not-satisfied'
+}
+
+export interface IPythonEnvResolveError {
+  type: PythonEnvResolveErrorType;
+  message?: string;
+}
+
 export interface IDisposable {
   dispose(): Promise<void>;
 }
diff --git a/src/main/utils.ts b/src/main/utils.ts
index fc266989..5800df29 100644
--- a/src/main/utils.ts
+++ b/src/main/utils.ts
@@ -443,6 +443,12 @@ export function createCommandScriptInEnv(
 
   let hasActivate = fs.existsSync(activatePath);
   const isConda = isCondaEnv(envPath);
+  // conda commands don't work properly when called from the sub environment.
+  // instead call using conda from the base environment with -p parameter
+  const isCondaCommand = isConda && command?.startsWith('conda ');
+  if (isCondaCommand && !isBaseCondaEnv(envPath)) {
+    command = `${command} -p ${envPath}`;
+  }
 
   // conda activate is only available in base conda environments or
   // conda-packed environments
@@ -474,7 +480,9 @@ export function createCommandScriptInEnv(
     scriptLines.push(`source "${activatePath}"`);
     if (isConda && isBaseCondaActivate) {
       scriptLines.push(`source "${condaSourcePath}"`);
-      scriptLines.push(`conda activate "${envPath}"`);
+      if (!isCondaCommand) {
+        scriptLines.push(`conda activate "${envPath}"`);
+      }
     }
     if (command) {
       scriptLines.push(command);
@@ -514,3 +522,20 @@ export function createUnsignScriptInEnv(envPath: string): string {
     ' '
   )} && ${removeRuntimeFlagCommand} && cd -`;
 }
+
+export function getLogFilePath(processType: 'main' | 'renderer' = 'main') {
+  switch (process.platform) {
+    case 'win32':
+      return path.join(getUserDataDir(), `\\logs\\${processType}.log`);
+    case 'darwin':
+      return path.join(
+        getUserHomeDir(),
+        `/Library/Logs/jupyterlab-desktop/${processType}.log`
+      );
+    default:
+      return path.join(
+        getUserHomeDir(),
+        `/.config/jupyterlab-desktop/logs/${processType}.log`
+      );
+  }
+}