fix(cli): improve error handling and adjust child process spawning logic

Author: Romakita

packages/cli-core/src/CliCore.ts

@@ -109,7 +109,6 @@ export class CliCore {
       const cliService = inject(CliService);
       constant("plugins") && (await loadPlugins());
 
-      await $asyncEmit("$beforeInit");
       await injector().load();
       await $asyncEmit("$afterInit");
 

packages/cli-core/src/services/CliHttpClient.spec.ts

@@ -9,10 +9,12 @@ describe("CliHttpClient", () => {
   beforeEach(() => DITest.create());
   afterEach(() => DITest.reset());
 
-  describe("$afterInit()", () => {
-    it("should call $afterInit method", async () => {
+  describe("proxy settings", () => {
+    it("should resolve proxy settings once for non-local HTTP endpoints", async () => {
       const cliProxyAgent = {
-        resolveProxySettings: vi.fn()
+        resolveProxySettings: vi.fn().mockResolvedValue(undefined),
+        hasProxy: vi.fn().mockReturnValue(false),
+        get: vi.fn().mockReturnValue(null)
       };
       const client = await DITest.invoke<CliHttpClient>(CliHttpClient, [
         {
@@ -21,9 +23,15 @@ describe("CliHttpClient", () => {
         }
       ]);
 
-      await client.$afterInit();
+      (axios as any).mockResolvedValue({
+        headers: {},
+        data: {}
+      });
+
+      await client.get("https://api.tsed.dev/test");
+      await client.get("https://api.tsed.dev/test");
 
-      expect(cliProxyAgent.resolveProxySettings).toHaveBeenCalled();
+      expect(cliProxyAgent.resolveProxySettings).toHaveBeenCalledTimes(1);
     });
   });
   describe("head()", () => {

packages/cli-core/src/services/CliHttpClient.ts

@@ -15,56 +15,55 @@ export interface CliHttpClientOptions extends AxiosRequestConfig, Record<string,
 
 export class CliHttpClient extends CliHttpLogClient {
   protected cliProxyAgent = inject(CliProxyAgent);
-
   protected host: string;
+  private proxySettingsInitialized = false;
+  private proxySettingsPromise?: Promise<void>;
 
   static getParamsSerializer(params: any) {
     return stringify(cleanObject(params));
   }
 
-  async $afterInit() {
-    await this.cliProxyAgent.resolveProxySettings();
-  }
-
   async head<T = Record<string, any>>(endpoint: string, options: CliHttpClientOptions = {}): Promise<T> {
-    const {headers} = await axios(this.getRequestParameters("HEAD", endpoint, options));
+    const {headers} = await axios(await this.getRequestParameters("HEAD", endpoint, options));
 
     return headers as any;
   }
 
   async get<T = unknown>(endpoint: string, options: CliHttpClientOptions = {}): Promise<T> {
-    const result = await this.send(this.getRequestParameters("GET", endpoint, options));
+    const result = await this.send(await this.getRequestParameters("GET", endpoint, options));
 
     return this.mapResponse(result, options);
   }
 
   async post<T = unknown>(endpoint: string, options: CliHttpClientOptions = {}): Promise<T> {
-    const result = await this.send(this.getRequestParameters("POST", endpoint, options));
+    const result = await this.send(await this.getRequestParameters("POST", endpoint, options));
 
     return this.mapResponse(result, options);
   }
 
   async put<T = any>(endpoint: string, options: CliHttpClientOptions = {}): Promise<T> {
-    const result = await this.send(this.getRequestParameters("PUT", endpoint, options));
+    const result = await this.send(await this.getRequestParameters("PUT", endpoint, options));
 
     return this.mapResponse(result, options);
   }
 
   async patch<T = any>(endpoint: string, options: CliHttpClientOptions = {}): Promise<T> {
-    const result = await this.send(this.getRequestParameters("PATCH", endpoint, options));
+    const result = await this.send(await this.getRequestParameters("PATCH", endpoint, options));
 
     return this.mapResponse(result, options);
   }
 
   async delete<T = any>(endpoint: string, options: CliHttpClientOptions = {}): Promise<T> {
-    const result = await this.send(this.getRequestParameters("DELETE", endpoint, options));
+    const result = await this.send(await this.getRequestParameters("DELETE", endpoint, options));
 
     return this.mapResponse(result, options);
   }
 
-  protected getRequestParameters(method: Method, endpoint: string, options: CliHttpClientOptions) {
+  protected async getRequestParameters(method: Method, endpoint: string, options: CliHttpClientOptions) {
     const url = (this.host || "") + endpoint.replace(this.host || "", "");
 
+    await this.resolveProxySettingsOnce();
+
     options = {
       method,
       ...options,
@@ -78,23 +77,42 @@ export class CliHttpClient extends CliHttpLogClient {
       }
     };
 
-    this.configureProxy(url, options);
+    await this.configureProxy(url, options);
 
     return options;
   }
 
-  protected configureProxy(endpoint: string, options: CliHttpClientOptions) {
+  private async resolveProxySettingsOnce() {
+    if (this.proxySettingsInitialized) {
+      return;
+    }
+
+    if (!this.proxySettingsPromise) {
+      this.proxySettingsPromise = this.cliProxyAgent
+        .resolveProxySettings()
+        .catch(() => {
+          return;
+        })
+        .finally(() => {
+          this.proxySettingsInitialized = true;
+        });
+    }
+
+    await this.proxySettingsPromise;
+  }
+
+  protected async configureProxy(endpoint: string, options: CliHttpClientOptions) {
     const url = new URL(endpoint);
 
     if (this.cliProxyAgent.hasProxy()) {
       const protocol = url.protocol.replace(":", "");
       switch (protocol) {
         case "https":
-          options.httpsAgent = this.cliProxyAgent.get(protocol);
+          options.httpsAgent = await this.cliProxyAgent.get(protocol);
           options.proxy = false;
           break;
         case "http":
-          options.httpAgent = this.cliProxyAgent.get(protocol);
+          options.httpAgent = await this.cliProxyAgent.get(protocol);
           options.proxy = false;
           break;
         default:

packages/cli-core/src/services/CliProxyAgent.ts

@@ -16,18 +16,14 @@ export class CliProxyAgent {
   readonly proxySettings = refValue<CliProxySettings>("proxy", {} as never);
   protected projectPackageJson = inject(ProjectPackageJson);
   protected cliExeca = inject(CliExeca);
-  protected tunnel: typeof import("tunnel");
-
-  async $onInit() {
-    this.tunnel = await import("tunnel");
-  }
 
   hasProxy() {
     return !!this.proxySettings.value.url;
   }
 
-  get(type: "http" | "https") {
+  async get(type: "http" | "https") {
     if (this.hasProxy()) {
+      const tunnel = await import("tunnel");
       const {strictSsl = true} = this.proxySettings.value;
       const url = new URL(this.proxySettings.value.url);
       const protocol = url.protocol.replace(":", "");
@@ -43,8 +39,8 @@ export class CliProxyAgent {
 
       const method = camelCase([type, "over", protocol].join(" "));
 
-      if ((this.tunnel as any)[method]) {
-        return (this.tunnel as any)[method](options);
+      if ((tunnel as any)[method]) {
+        return (tunnel as any)[method](options);
       }
     }
 

packages/cli/src/bin/tsed-dev.ts

@@ -88,7 +88,9 @@ async function runViteController(rawArgs: string[]) {
   let queued = false;
 
   const startChild = () => {
-    childProcess = spawn(process.execPath, [runnerFile, ...rawArgs], {
+    const cliEntry = process.argv[1];
+
+    childProcess = spawn(process.execPath, cliEntry ? [cliEntry, "dev", ...rawArgs] : [runnerFile, ...rawArgs], {
       env: {
         ...process.env,
         [RUN_MODE]: "app"