fix: can open ide from sketch folder path

Signed-off-by: Akos Kitta <[email protected]>

Author: Akos Kitta

arduino-ide-extension/src/electron-main/theia/electron-main-application.ts

@@ -8,8 +8,8 @@ import {
 } from '@theia/core/electron-shared/electron';
 import { fork } from 'child_process';
 import { AddressInfo } from 'net';
-import { join, dirname } from 'path';
-import * as fs from 'fs-extra';
+import { join, dirname, isAbsolute, resolve } from 'path';
+import { promises as fs, Stats } from 'fs';
 import { MaybePromise } from '@theia/core/lib/common/types';
 import { ElectronSecurityToken } from '@theia/core/lib/electron-common/electron-token';
 import { FrontendApplicationConfig } from '@theia/application-package/lib/application-props';
@@ -69,8 +69,10 @@ export class ElectronMainApplication extends TheiaElectronMainApplication {
     // Explicitly set the app name to have better menu items on macOS. ("About", "Hide", and "Quit")
     // See: https://github.com/electron-userland/electron-builder/issues/2468
     // Regression in Theia: https://github.com/eclipse-theia/theia/issues/8701
+    console.log(`${config.applicationName} ${app.getVersion()}`);
     app.on('ready', () => app.setName(config.applicationName));
-    this.attachFileAssociations();
+    const cwd = process.cwd();
+    this.attachFileAssociations(cwd);
     this.useNativeWindowFrame = this.getTitleBarStyle(config) === 'native';
     this._config = config;
     this.hookApplicationEvents();
@@ -84,7 +86,7 @@ export class ElectronMainApplication extends TheiaElectronMainApplication {
     return this.launch({
       secondInstance: false,
       argv: this.processArgv.getProcessArgvWithoutBin(process.argv),
-      cwd: process.cwd(),
+      cwd
     });
   }
 
@@ -119,7 +121,7 @@ export class ElectronMainApplication extends TheiaElectronMainApplication {
       let traceFile: string | undefined;
       if (appPath) {
         const tracesPath = join(appPath, 'traces');
-        await fs.promises.mkdir(tracesPath, { recursive: true });
+        await fs.mkdir(tracesPath, { recursive: true });
         traceFile = join(tracesPath, `trace-${new Date().toISOString()}.trace`);
       }
       console.log('>>> Content tracing has started...');
@@ -135,14 +137,16 @@ export class ElectronMainApplication extends TheiaElectronMainApplication {
     })();
   }
 
-  private attachFileAssociations(): void {
+  private attachFileAssociations(cwd: string): void {
     // OSX: register open-file event
     if (os.isOSX) {
-      app.on('open-file', async (event, uri) => {
+      app.on('open-file', async (event, path) => {
         event.preventDefault();
-        if (uri.endsWith('.ino') && (await fs.pathExists(uri))) {
+        const resolvedPath = await this.resolvePath(path, cwd);
+        const sketchFolderPath = await this.isValidSketchPath(resolvedPath);
+        if (sketchFolderPath) {
           this.openFilePromise.reject(new InterruptWorkspaceRestoreError());
-          await this.openSketch(dirname(uri));
+          await this.openSketch(sketchFolderPath);
         }
       });
       setTimeout(() => this.openFilePromise.resolve(), 500);
@@ -151,8 +155,49 @@ export class ElectronMainApplication extends TheiaElectronMainApplication {
     }
   }
 
-  private async isValidSketchPath(uri: string): Promise<boolean | undefined> {
-    return typeof uri === 'string' && (await fs.pathExists(uri));
+  /**
+   * The `path` argument is valid, if accessible and either pointing to a `.ino` file,
+   * or it's a directory, and one of the files in the directory is an `.ino` file.
+   * The resolved filesystem path is pointing to the sketch folder to open in IDE2.
+   * If `undefined`, `path` was pointing to neither an accessible sketch file nor a sketch folder.
+   *
+   * The sketch folder name and sketch file name can be different. This method is not that strict.
+   * The `path` must be an absolute path.
+   */
+  private async isValidSketchPath(path: string): Promise<string | undefined> {
+    let stats: Stats | undefined = undefined;
+    try {
+      stats = await fs.stat(path);
+    } catch (err) {
+      if ('code' in err && err.code === 'ENOENT') {
+        return undefined;
+      }
+      throw err;
+    }
+    if (!stats) {
+      return undefined;
+    }
+    if (stats.isFile() && path.endsWith('.ino')) {
+      return dirname(path);
+    }
+    try {
+      const entries = await fs.readdir(path, { withFileTypes: true });
+      if (
+        entries.some((entry) => entry.isFile() && entry.name.endsWith('.ino'))
+      ) {
+        return path;
+      }
+    } catch (err) {
+      throw err;
+    }
+    return undefined;
+  }
+
+  private async resolvePath(path: string, cwd: string): Promise<string> {
+    if (isAbsolute(path)) {
+      return path;
+    }
+    return fs.realpath(resolve(cwd, path));
   }
 
   protected override async launch(
@@ -171,7 +216,7 @@ export class ElectronMainApplication extends TheiaElectronMainApplication {
       throw err;
     }
 
-    if (!os.isOSX && (await this.launchFromArgs(params))) {
+    if (await this.launchFromArgs(params)) {
       // Application has received a file in its arguments and will skip the default application launch
       return;
     }
@@ -185,7 +230,10 @@ export class ElectronMainApplication extends TheiaElectronMainApplication {
         `Restoring workspace roots: ${workspaces.map(({ file }) => file)}`
       );
       for (const workspace of workspaces) {
-        if (await this.isValidSketchPath(workspace.file)) {
+        const resolvedPath = await this.resolvePath(workspace.file, params.cwd);
+        const sketchFolderPath = await this.isValidSketchPath(resolvedPath);
+        if (sketchFolderPath) {
+          workspace.file = sketchFolderPath;
           if (this.isTempSketch.is(workspace.file)) {
             console.info(
               `Skipped opening sketch. The sketch was detected as temporary. Workspace path: ${workspace.file}.`
@@ -208,38 +256,37 @@ export class ElectronMainApplication extends TheiaElectronMainApplication {
   ): Promise<boolean> {
     // Copy to prevent manipulation of original array
     const argCopy = [...params.argv];
-    let uri: string | undefined;
-    for (const possibleUri of argCopy) {
-      if (
-        possibleUri.endsWith('.ino') &&
-        (await this.isValidSketchPath(possibleUri))
-      ) {
-        uri = possibleUri;
+    let path: string | undefined;
+    for (const maybePath of argCopy) {
+      const resolvedPath = await this.resolvePath(maybePath, params.cwd);
+      const sketchFolderPath = await this.isValidSketchPath(resolvedPath);
+      if (sketchFolderPath) {
+        path = sketchFolderPath;
         break;
       }
     }
-    if (uri) {
-      await this.openSketch(dirname(uri));
+    if (path) {
+      await this.openSketch(path);
       return true;
     }
     return false;
   }
 
   private async openSketch(
-    workspace: WorkspaceOptions | string
+    workspaceOrPath: WorkspaceOptions | string
   ): Promise<BrowserWindow> {
     const options = await this.getLastWindowOptions();
     let file: string;
-    if (typeof workspace === 'object') {
-      options.x = workspace.x;
-      options.y = workspace.y;
-      options.width = workspace.width;
-      options.height = workspace.height;
-      options.isMaximized = workspace.isMaximized;
-      options.isFullScreen = workspace.isFullScreen;
-      file = workspace.file;
+    if (typeof workspaceOrPath === 'object') {
+      options.x = workspaceOrPath.x;
+      options.y = workspaceOrPath.y;
+      options.width = workspaceOrPath.width;
+      options.height = workspaceOrPath.height;
+      options.isMaximized = workspaceOrPath.isMaximized;
+      options.isFullScreen = workspaceOrPath.isFullScreen;
+      file = workspaceOrPath.file;
     } else {
-      file = workspace;
+      file = workspaceOrPath;
     }
     const [uri, electronWindow] = await Promise.all([
       this.createWindowUri(),