fix: add .exe for windows

Author: Amour1688

.github/workflows/ci.yml

@@ -45,13 +45,16 @@ jobs:
           go-version: ${{ matrix.go-version }}
           cache-name: test-go
       - name: golangci-lint
+        if: ${{ runner.os == 'Linux' && runner.environment == 'self-hosted' }}
         uses: golangci/golangci-lint-action@v8
         with:
           version: v2.3.0
           args: --timeout=5m ./cmd/... ./internal/...
       - name: go vet
+        if: ${{ runner.os == 'Linux' && runner.environment == 'self-hosted' }}
         run: npm run lint:go
       - name: go fmt
+        if: ${{ runner.os == 'Linux' && runner.environment == 'self-hosted' }}
         run: npm run format:go
       - name: Unit Test
         run: |

packages/vscode-extension/src/Rslint.ts

@@ -15,7 +15,7 @@ import {
   Trace,
 } from 'vscode-languageclient/node';
 import { Logger } from './logger';
-import type { Extension } from './Extension';
+import type { Extension } from './extension';
 import { fileExists, PLATFORM_BIN_REQUEST, RslintBinPath } from './utils';
 import { dirname } from 'node:path';
 

packages/vscode-extension/src/extension.ts

@@ -0,0 +1,138 @@
+import {
+  ExtensionContext,
+  Disposable,
+  workspace,
+  WorkspaceFolder,
+  ExtensionMode,
+} from 'vscode';
+import { State } from 'vscode-languageclient/node';
+import { LogLevel, Logger } from './logger';
+import { Rslint } from './rslint';
+
+export class Extension implements Disposable {
+  private rslintInstances: Map<string, Rslint> = new Map();
+  private disposables: Disposable[] = [];
+  private logger: Logger;
+  public context: ExtensionContext;
+
+  constructor(context: ExtensionContext) {
+    Logger.setDefaultLogLevel(context);
+    this.context = context;
+    this.logger = new Logger('Rslint (extension)').useDefaultLogLevel();
+  }
+
+  public async activate(): Promise<void> {
+    this.logger.info('Rslint extension activating...');
+
+    const folders = workspace.workspaceFolders ?? [];
+    for (const folder of folders) {
+      const workspaceRslint = this.createRslintInstance(folder.name, folder);
+      await workspaceRslint.start();
+      this.setupStateChangeMonitoring(workspaceRslint, folder.name);
+    }
+
+    this.logger.info('Rslint extension activated successfully');
+  }
+
+  public async deactivate(): Promise<void> {
+    this.logger.info('Rslint extension deactivating...');
+
+    const stopPromises = Array.from(this.rslintInstances.values()).map(
+      instance => instance.stop(),
+    );
+
+    try {
+      await Promise.all(stopPromises);
+      this.logger.info('All Rslint instances stopped');
+    } catch (err: unknown) {
+      this.logger.error('Error stopping some Rslint instances', err);
+    }
+
+    this.dispose();
+    this.logger.info('Rslint extension deactivated');
+  }
+
+  public createRslintInstance(
+    id: string,
+    workspaceFolder: WorkspaceFolder,
+  ): Rslint {
+    if (this.rslintInstances.has(id)) {
+      this.logger.warn(`Rslint instance with id '${id}' already exists`);
+      return this.rslintInstances.get(id)!;
+    }
+
+    // TODO: single file mode
+    const rslint = new Rslint(this, workspaceFolder);
+    this.rslintInstances.set(id, rslint);
+    this.logger.debug(`Created Rslint instance with id: ${id}`);
+    return rslint;
+  }
+
+  public getRslintInstance(id: string): Rslint | undefined {
+    return this.rslintInstances.get(id);
+  }
+
+  public async removeRslintInstance(id: string): Promise<void> {
+    const instance = this.rslintInstances.get(id);
+    if (!instance) {
+      this.logger.warn(`Rslint instance with id '${id}' not found`);
+      return;
+    }
+
+    await instance.stop();
+    instance.dispose();
+    this.rslintInstances.delete(id);
+
+    this.logger.debug(`Removed Rslint instance with id: ${id}`);
+  }
+
+  public getAllRslintInstances(): Map<string, Rslint> {
+    return new Map(this.rslintInstances);
+  }
+
+  public dispose(): void {
+    this.rslintInstances.forEach(instance => {
+      instance.dispose();
+    });
+    this.rslintInstances.clear();
+
+    this.disposables.forEach(disposable => {
+      disposable.dispose();
+    });
+    this.disposables = [];
+
+    this.logger.dispose();
+  }
+
+  private setupLogging(): void {
+    this.logger.setLogLevel(
+      this.context.extensionMode === ExtensionMode.Development
+        ? LogLevel.DEBUG
+        : LogLevel.INFO,
+    );
+  }
+
+  private setupStateChangeMonitoring(rslint: Rslint, instanceId: string): void {
+    const stateChangeDisposable = rslint.onDidChangeState(event => {
+      this.logger.debug(
+        `Rslint client state changed for instance '${instanceId}':`,
+        event.oldState,
+        '->',
+        event.newState,
+      );
+
+      if (event.newState === State.Running) {
+        this.logger.info(
+          `Rslint language server started for instance '${instanceId}'`,
+        );
+      } else if (event.newState === State.Stopped) {
+        this.logger.info(
+          `Rslint language server stopped for instance '${instanceId}'`,
+        );
+      }
+    });
+
+    this.disposables.push(stateChangeDisposable);
+    this.context.subscriptions.push(stateChangeDisposable);
+  }
+}

packages/vscode-extension/src/main.ts

@@ -1,5 +1,5 @@
 import { ExtensionContext } from 'vscode';
-import { Extension } from './Extension';
+import { Extension } from './extension';
 
 let extension: Extension;