@tramvai/cli 3.26.3 → 3.27.3

package/src/api/shared/utils/selfSignedCertificate/common.ts

@@ -0,0 +1,4 @@
+import path from 'path';
+
+export const certificateDirectory = 'certificates';
+export const certificateDirectoryPath = path.resolve(process.cwd(), certificateDirectory);

package/src/api/shared/utils/selfSignedCertificate/createSelfSignedCertificate.spec.ts

@@ -0,0 +1,154 @@
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+import child_process from 'child_process';
+
+import { createSelfSignedCertificate } from './createSelfSignedCertificate';
+import { certificatedHostsListFilePath } from './certificatedHostsList';
+import { certificateDirectoryPath } from './common';
+
+const defaultKeyPath = path.resolve(certificateDirectoryPath, 'localhost-key.pem');
+const defaultCertificatePath = path.resolve(certificateDirectoryPath, 'localhost.pem');
+const gitignorePath = path.resolve(process.cwd(), '.gitignore');
+const customHost = 'localhost.domain.com';
+
+jest.mock('os', () => {
+  return {
+    networkInterfaces: (param: string) => {
+      return [];
+    },
+  };
+});
+
+const existsSyncSpy = jest.spyOn(fs, 'existsSync');
+const mkdirSyncSpy = jest.spyOn(fs, 'mkdirSync');
+const writeFileSyncSpy = jest.spyOn(fs, 'writeFileSync');
+const readFileSyncSpy = jest.spyOn(fs, 'readFileSync');
+const execSyncSpy = jest.spyOn(child_process, 'execSync');
+const appendFileSyncSpy = jest.spyOn(fs, 'appendFileSync');
+
+describe('shared/utils/selfSignedCertificate', () => {
+  beforeEach(() => {
+    writeFileSyncSpy.mockImplementation(() => undefined);
+    mkdirSyncSpy.mockImplementation(() => {
+      return undefined;
+    });
+    execSyncSpy.mockImplementation((command) => {
+      if (command === 'mkcert -CAROOT') return '/location';
+      return '';
+    });
+
+    readFileSyncSpy.mockImplementation((path) => {
+      if (path === gitignorePath) return '';
+      return `localhost,${customHost}`;
+    });
+  });
+  afterEach(() => {
+    jest.clearAllMocks();
+    existsSyncSpy.mockReset();
+    mkdirSyncSpy.mockReset();
+    writeFileSyncSpy.mockReset();
+    execSyncSpy.mockReset();
+  });
+  it('should generate certificate', async () => {
+    existsSyncSpy.mockImplementation((path) => {
+      if (path === certificatedHostsListFilePath || path === gitignorePath) {
+        return false;
+      }
+      return true;
+    });
+
+    const result = createSelfSignedCertificate({});
+
+    expect(execSyncSpy).toHaveBeenNthCalledWith(
+      1,
+      `mkcert -install -key-file "${defaultKeyPath}" -cert-file "${defaultCertificatePath}" localhost`
+    );
+
+    expect(result).toEqual({
+      keyPath: defaultKeyPath,
+      certificatePath: defaultCertificatePath,
+    });
+  });
+  it('should generate certificate for provided host', async () => {
+    existsSyncSpy.mockImplementation((path) => {
+      if (path === certificatedHostsListFilePath || path === gitignorePath) {
+        return false;
+      }
+      return true;
+    });
+    const result = createSelfSignedCertificate({ host: customHost });
+    expect(execSyncSpy).toHaveBeenNthCalledWith(
+      1,
+      `mkcert -install -key-file "${defaultKeyPath}" -cert-file "${defaultCertificatePath}" localhost ${customHost}`
+    );
+    expect(result).toEqual({
+      keyPath: defaultKeyPath,
+      certificatePath: defaultCertificatePath,
+    });
+  });
+
+  it('should return already existed certificate if it was generated previously', async () => {
+    existsSyncSpy.mockImplementation((path) => {
+      if (path === gitignorePath) {
+        return false;
+      }
+      return true;
+    });
+    const result = createSelfSignedCertificate({ host: customHost });
+    expect(execSyncSpy).toHaveBeenCalledTimes(0);
+
+    expect(result).toEqual({
+      keyPath: defaultKeyPath,
+      certificatePath: defaultCertificatePath,
+    });
+  });
+
+  it('should use custom certificate if provided', () => {
+    const customCertificate = {
+      certificatePath: path.resolve('path-to-custom-certificate/cert.pem'),
+      keyPath: path.resolve('path-to-custom-certificate/key.pem'),
+    };
+    const result = createSelfSignedCertificate({
+      host: customHost,
+      ...customCertificate,
+    });
+
+    expect(execSyncSpy).toHaveBeenCalledTimes(0);
+
+    expect(result).toEqual({
+      keyPath: customCertificate.keyPath,
+      certificatePath: customCertificate.certificatePath,
+    });
+  });
+  it('if a new host be provided, a new certificate should be generated even if a certificate already exists.', () => {
+    existsSyncSpy.mockImplementation((path) => {
+      if (path === gitignorePath) {
+        return false;
+      }
+      return true;
+    });
+    const result = createSelfSignedCertificate({ host: 'new.localhost.domain' });
+    expect(execSyncSpy).toHaveBeenNthCalledWith(
+      1,
+      `mkcert -install -key-file "${defaultKeyPath}" -cert-file "${defaultCertificatePath}" localhost new.localhost.domain`
+    );
+
+    expect(result).toEqual({
+      keyPath: defaultKeyPath,
+      certificatePath: defaultCertificatePath,
+    });
+  });
+  it('should add certificates folder to .gitignore if .gitignore file exist', () => {
+    existsSyncSpy.mockImplementation((path) => {
+      return true;
+    });
+    const result = createSelfSignedCertificate({ host: 'new.localhost.domain' });
+    expect(appendFileSyncSpy).toBeCalledTimes(1);
+
+    expect(result).toEqual({
+      keyPath: defaultKeyPath,
+      certificatePath: defaultCertificatePath,
+    });
+  });
+});

package/src/api/shared/utils/selfSignedCertificate/createSelfSignedCertificate.ts

@@ -0,0 +1,99 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+import type { Certificate } from '../../types/base';
+import { getHosts } from './getHosts';
+import { certificateDirectoryPath, certificateDirectory } from './common';
+import {
+  createCertificatedHostsListFile,
+  readCertificatedHostsListFile,
+} from './certificatedHostsList';
+
+interface CreateSelfSignedCertificateOptions {
+  host?: string;
+  keyPath?: string;
+  certificatePath?: string;
+}
+
+// eslint-disable-next-line max-statements
+export const createSelfSignedCertificate = (
+  options: CreateSelfSignedCertificateOptions
+): Certificate => {
+  try {
+    const { host } = options;
+    const hosts = getHosts(host === '0.0.0.0' ? null : host);
+    const hostsFile = readCertificatedHostsListFile();
+
+    const defaultKeyPath = path.resolve(certificateDirectoryPath, 'localhost-key.pem');
+    const defaultCertificatePath = path.resolve(certificateDirectoryPath, 'localhost.pem');
+
+    const keyPath = options.keyPath ? path.resolve(options.keyPath) : defaultKeyPath;
+    const certificatePath = options.certificatePath
+      ? path.resolve(options.certificatePath)
+      : defaultCertificatePath;
+
+    // check if certificates are already generated, in this case we simply skip step
+
+    const isExternalCertificateProvided = options.certificatePath && options.keyPath;
+
+    const isCertificateAlreadyExist =
+      !isExternalCertificateProvided &&
+      fs.existsSync(keyPath) &&
+      fs.existsSync(certificatePath) &&
+      hostsFile &&
+      hosts.every((h) => hostsFile.has(h));
+
+    const gitignorePath = path.resolve(process.cwd(), '.gitignore');
+    if (
+      fs.existsSync(gitignorePath) &&
+      !fs.readFileSync(gitignorePath, 'utf-8').includes(certificateDirectory)
+    ) {
+      fs.appendFileSync(gitignorePath, `\n${certificateDirectory}`);
+    }
+
+    if (isExternalCertificateProvided || isCertificateAlreadyExist) {
+      console.log(
+        chalk.blue(
+          'Certificates for https environment are already exist, skipping step with certificate generation'
+        )
+      );
+
+      return {
+        keyPath,
+        certificatePath,
+      };
+    }
+
+    fs.mkdirSync(certificateDirectoryPath, { recursive: true });
+    createCertificatedHostsListFile(hosts);
+
+    // TODO: maybe it is better to install mkcert for users for better dx
+    // check https://github.com/liuweiGL/vite-plugin-mkcert/blob/main/plugin/index.ts and https://github.com/vercel/next.js/blob/28fdc367b1f6d41245ea036bc40d1035a8a4d0e4/packages/next/src/lib/mkcert.ts#L68
+    execSync(
+      `mkcert -install -key-file "${keyPath}" -cert-file "${certificatePath}" ${hosts.join(' ')}`
+    );
+
+    if (!fs.existsSync(keyPath) || !fs.existsSync(certificatePath)) {
+      throw new Error(
+        'Error occured while certificate creation. Generated certificate files not found'
+      );
+    }
+
+    const CAROOTFileLocation = execSync('mkcert -CAROOT').toString().trim();
+
+    console.log(chalk.green(`Root certificate located in ${chalk.blue(CAROOTFileLocation)}`));
+
+    return {
+      keyPath,
+      certificatePath,
+    };
+  } catch (error) {
+    console.error(
+      chalk.red(
+        `Error while generating the certificate. The mkcert tool may not be installed please check and install it if that is the case.`
+      )
+    );
+    throw new Error(error);
+  }
+};

package/src/api/shared/utils/selfSignedCertificate/getHosts.ts

@@ -0,0 +1,31 @@
+import os from 'os';
+
+export const getDefaultHosts = () => {
+  const defaultHosts = ['localhost'];
+  const networkInterfaces = os.networkInterfaces();
+
+  for (const networkInterfaceKey in networkInterfaces) {
+    const networkInterfacesInfo = networkInterfaces[networkInterfaceKey];
+
+    if (networkInterfacesInfo) {
+      for (const info of networkInterfacesInfo) {
+        // https://github.com/nodejs/node/issues/42787
+        //@ts-expect-error
+        if (info.family === 'IPv4' || info.family === '4') {
+          defaultHosts.push(info.address);
+        }
+      }
+    }
+  }
+
+  return defaultHosts;
+};
+
+export const getHosts = (host?: string) => {
+  const hosts = new Set([...getDefaultHosts()]);
+
+  if (host && !hosts.has(host)) {
+    hosts.add(host);
+  }
+  return Array.from(hosts);
+};

package/src/api/start/index.ts

@@ -11,6 +11,9 @@ import type { Builder } from '../../typings/build/Builder';
 
 export type Params = WithConfig<{
   buildType?: 'server' | 'client' | 'all';
+  https?: boolean;
+  httpsKey?: string;
+  httpsCert?: string;
   host?: string;
   port?: number;
   staticPort?: number;

package/src/api/start/providers/application/server.ts

@@ -1,8 +1,13 @@
 import type { Provider } from '@tinkoff/dippy';
 import { provide } from '@tinkoff/dippy';
-
+import { readFileSync } from 'fs';
+import { createProxyServer } from 'http-proxy';
 import { INIT_HANDLER_TOKEN, CLOSE_HANDLER_TOKEN } from '../../tokens';
-import { CONFIG_MANAGER_TOKEN, SERVER_TOKEN } from '../../../../di/tokens';
+import {
+  CONFIG_MANAGER_TOKEN,
+  SELF_SIGNED_CERTIFICATE_TOKEN,
+  SERVER_TOKEN,
+} from '../../../../di/tokens';
 import { stopServer } from '../../utils/stopServer';
 import { createServer } from '../../utils/createServer';
 import { listenServer } from '../../utils/listenServer';
@@ -10,14 +15,24 @@ import { listenServer } from '../../utils/listenServer';
 export const serverProviders: readonly Provider[] = [
   provide({
     provide: SERVER_TOKEN,
-    useFactory: createServer,
+    useFactory: ({ selfSignedCertificate }) => {
+      return createServer(selfSignedCertificate);
+    },
+    deps: {
+      selfSignedCertificate: {
+        token: SELF_SIGNED_CERTIFICATE_TOKEN,
+        optional: true,
+      },
+    },
   }),
   provide({
     provide: INIT_HANDLER_TOKEN,
     multi: true,
-    useFactory: ({ server, configManager }) => {
+    useFactory: ({ server, configManager, selfSignedCertificate }) => {
       return async function staticServerListen() {
-        const { host, port } = configManager;
+        const { https } = configManager;
+        const port = https && configManager.host !== '0.0.0.0' ? 443 : configManager.port;
+        const host = https ? '0.0.0.0' : configManager.host;
 
         await listenServer(server, host, port);
       };
@@ -25,6 +40,7 @@ export const serverProviders: readonly Provider[] = [
     deps: {
       server: SERVER_TOKEN,
       configManager: CONFIG_MANAGER_TOKEN,
+      selfSignedCertificate: SELF_SIGNED_CERTIFICATE_TOKEN,
     },
   }),
   provide({

package/src/api/start/providers/application/shared.ts

@@ -1,6 +1,5 @@
 import type { Provider } from '@tinkoff/dippy';
 import { provide } from '@tinkoff/dippy';
-
 import { CLOSE_HANDLER_TOKEN, INIT_HANDLER_TOKEN } from '../../tokens';
 import {
   CONFIG_MANAGER_TOKEN,
@@ -8,14 +7,17 @@ import {
   COMMAND_PARAMETERS_TOKEN,
   STATIC_SERVER_TOKEN,
   PORT_MANAGER_TOKEN,
+  SELF_SIGNED_CERTIFICATE_TOKEN,
 } from '../../../../di/tokens';
 import { stopServer } from '../../utils/stopServer';
 import type { ApplicationConfigEntry } from '../../../../typings/configEntry/application';
 import { createConfigManager } from '../../../../config/configManager';
 import { createServer } from '../../utils/createServer';
 import { listenServer } from '../../utils/listenServer';
+import { selfSignedCertificateProvider } from '../../../shared/providers/selfSignedCertificateProvider';
 
 export const sharedProviders: readonly Provider[] = [
+  ...selfSignedCertificateProvider,
   provide({
     provide: CONFIG_MANAGER_TOKEN,
     useFactory: ({ configEntry, parameters, portManager }) =>
@@ -34,7 +36,15 @@ export const sharedProviders: readonly Provider[] = [
   }),
   provide({
     provide: STATIC_SERVER_TOKEN,
-    useFactory: createServer,
+    useFactory: ({ selfSignedCertificate }) => {
+      return createServer(selfSignedCertificate);
+    },
+    deps: {
+      selfSignedCertificate: {
+        token: SELF_SIGNED_CERTIFICATE_TOKEN,
+        optional: true,
+      },
+    },
   }),
   provide({
     provide: INIT_HANDLER_TOKEN,

package/src/api/start/utils/banner.ts

@@ -8,6 +8,7 @@ import { isApplication } from '../../../config/validate';
 const label = (name) => chalk.bold.cyan(`▸ ${name}:`);
 const link = (url) => chalk.underline.blue(url);
 
+// eslint-disable-next-line max-statements
 export function showBanner(di: Container) {
   if (!di.get({ token: UI_SHOW_BANNER_TOKEN, optional: true })) {
     return;
@@ -31,14 +32,21 @@ export function showBanner(di: Container) {
     titleLines.push(`${label('FileSystemPages')}  true`);
   }
 
-  const server = `http://${config.host.replace('0.0.0.0', 'localhost')}:${config.port}`;
-  const staticServer = `http://${config.staticHost.replace('0.0.0.0', 'localhost')}:${
-    config.staticPort
-  }`;
+  // TODO: add information about hosted url !
+  const baseServerUrl = `${config.httpProtocol}://${config.host.replace('0.0.0.0', 'localhost')}`;
+  const server = `${baseServerUrl}:${config.port}`;
+
+  const staticServer = `${config.httpProtocol}://${config.staticHost.replace(
+    '0.0.0.0',
+    'localhost'
+  )}:${config.staticPort}`;
 
   if (config.type === 'application') {
     // Listeners
     messageLines.push(chalk.bold('Static: ') + link(staticServer));
+    if (config.host !== '0.0.0.0' && config.https) {
+      messageLines.push(chalk.bold('App:    ') + link(baseServerUrl));
+    }
     messageLines.push(chalk.bold('App:    ') + link(server));
   }
 

package/src/api/start/utils/createServer.ts

@@ -1,8 +1,26 @@
 import { createServer as httpCreateServer } from 'http';
+import { createServer as httpsCreateServer } from 'https';
+import { readFileSync } from 'fs';
 import stoppable from 'stoppable';
+import type { Certificate } from '../../shared/types/base';
 
-export const createServer = () => {
+const createHttpsServer = ({ keyPath, certificatePath }: Certificate) => {
+  const options = {
+    key: readFileSync(keyPath),
+    cert: readFileSync(certificatePath),
+  };
+  const httpsServer = httpsCreateServer(options);
+  return stoppable(httpsServer, 0);
+};
+
+const createHttpServer = () => {
   const server = httpCreateServer();
 
   return stoppable(server, 0);
 };
+
+export const createServer = (certificate?: Certificate) => {
+  return certificate && certificate?.certificatePath && certificate?.keyPath
+    ? createHttpsServer(certificate)
+    : createHttpServer();
+};

package/src/api/start-prod/providers/application.ts

@@ -7,6 +7,8 @@ import {
   CONFIG_ENTRY_TOKEN,
   CONFIG_MANAGER_TOKEN,
   PORT_MANAGER_TOKEN,
+  SELF_SIGNED_CERTIFICATE_TOKEN,
+  STATIC_SERVER_TOKEN,
 } from '../../../di/tokens';
 import type { ApplicationConfigEntry } from '../../../typings/configEntry/application';
 import { CLOSE_HANDLER_TOKEN, SERVER_PROCESS_TOKEN } from '../tokens';
@@ -14,8 +16,23 @@ import { DEBUG_ARGV } from '../../../config/constants';
 import { safeRequire } from '../../../utils/safeRequire';
 import type { ConfigManager } from '../../../config/configManager';
 import { createConfigManager } from '../../../config/configManager';
+import { selfSignedCertificateProvider } from '../../shared/providers/selfSignedCertificateProvider';
+import { createServer } from '../../start/utils/createServer';
 
 export const applicationsProviders: readonly Provider[] = [
+  ...selfSignedCertificateProvider,
+  provide({
+    provide: STATIC_SERVER_TOKEN,
+    useFactory: ({ selfSignedCertificate }) => {
+      return createServer(selfSignedCertificate);
+    },
+    deps: {
+      selfSignedCertificate: {
+        token: SELF_SIGNED_CERTIFICATE_TOKEN,
+        optional: true,
+      },
+    },
+  }),
   provide({
     provide: CONFIG_MANAGER_TOKEN,
     useFactory: ({ configEntry, parameters, portManager }) =>
@@ -35,16 +52,15 @@ export const applicationsProviders: readonly Provider[] = [
   }),
   provide({
     provide: SERVER_PROCESS_TOKEN,
-    useFactory: ({ configManager, parameters }) => {
+    useFactory: ({ configManager, parameters, selfSignedCertificate }) => {
       const { env } = parameters;
       const serverConfigManager = (
         configManager as ConfigManager<ApplicationConfigEntry>
       ).withSettings({
         buildType: 'server',
       });
-      const { debug, port, assetsPrefix } = serverConfigManager;
+      const { debug, port, assetsPrefix, https } = serverConfigManager;
       const root = serverConfigManager.buildPath;
-
       return fork(path.resolve(root, 'server.js'), [], {
         execArgv: debug ? DEBUG_ARGV : [],
         cwd: root,
@@ -58,12 +74,20 @@ export const applicationsProviders: readonly Provider[] = [
           PORT: `${port}`,
           PORT_SERVER: `${port}`,
           ASSETS_PREFIX: assetsPrefix,
+          HOST: serverConfigManager.host,
+          HTTPS: serverConfigManager.https
+            ? JSON.stringify({
+                key: selfSignedCertificate.keyPath,
+                cert: selfSignedCertificate.certificatePath,
+              })
+            : null,
         },
       });
     },
     deps: {
       configManager: CONFIG_MANAGER_TOKEN,
       parameters: COMMAND_PARAMETERS_TOKEN,
+      selfSignedCertificate: SELF_SIGNED_CERTIFICATE_TOKEN,
     },
   }),
   provide({

package/src/api/start-prod/providers/child-app.ts

@@ -5,11 +5,17 @@ import {
   CONFIG_ENTRY_TOKEN,
   CONFIG_MANAGER_TOKEN,
   PORT_MANAGER_TOKEN,
+  STATIC_SERVER_TOKEN,
 } from '../../../di/tokens';
 import { createConfigManager } from '../../../config/configManager';
 import type { ChildAppConfigEntry } from '../../../typings/configEntry/child-app';
+import { createServer } from '../../start/utils/createServer';
 
 export const childAppProviders: readonly Provider[] = [
+  provide({
+    provide: STATIC_SERVER_TOKEN,
+    useFactory: createServer,
+  }),
   provide({
     provide: CONFIG_MANAGER_TOKEN,
     useFactory: ({ configEntry, parameters, portManager }) =>

package/src/api/start-prod/providers/shared.ts

@@ -6,16 +6,11 @@ import fastifyStatic from '@fastify/static';
 import zlib from 'zlib';
 import { CLOSE_HANDLER_TOKEN, INIT_HANDLER_TOKEN, PROCESS_HANDLER_TOKEN } from '../tokens';
 import { CONFIG_MANAGER_TOKEN, PORT_MANAGER_TOKEN, STATIC_SERVER_TOKEN } from '../../../di/tokens';
-import { createServer } from '../../start/utils/createServer';
 import { stopServer } from '../../start/utils/stopServer';
 import { listenServer } from '../../start/utils/listenServer';
 import { isApplication, isChildApp } from '../../../config/validate';
 
 export const sharedProviders: readonly Provider[] = [
-  provide({
-    provide: STATIC_SERVER_TOKEN,
-    useFactory: createServer,
-  }),
   provide({
     provide: INIT_HANDLER_TOKEN,
     multi: true,

package/src/builder/webpack/devServer/server.ts

@@ -17,6 +17,7 @@ import { ThreadWorkerBridge } from './pool/thread/pool';
 import { createWorkerPool } from './pool/pool';
 import type { SERVER_TOKEN } from '../../../di/tokens';
 import { CLOSE_HANDLER_TOKEN } from '../tokens';
+import { getApplicationUrl } from '../../../utils/getApplicationUrl';
 
 const EXITED_UNEXPECTEDLY = `
 
@@ -59,7 +60,11 @@ export const serverRunner = ({
     const file = `${Object.keys(config.entryPoints.entries())[0]}.js`;
     const filename = path.resolve(config.output.get('path'), file);
     // настоящая ссылка на файл используется для отладки в debug режиме
-    const realFilename = `http://${configManager.staticHost}:${configManager.staticPort}/${configManager.output.server}/${file}`;
+    const realFilename = `${getApplicationUrl({
+      host: configManager.staticHost,
+      port: configManager.staticPort,
+      protocol: configManager.httpProtocol,
+    })}/${configManager.output.server}/${file}`;
     const serverCompiler = compiler.compilers.find((comp) => comp.name === 'server');
 
     if (!serverCompiler) {

package/src/commands/start/command.ts

@@ -111,6 +111,22 @@ export class StartCommand extends CLICommand<Params> {
       transformer: (value: string) => value !== 'false',
       description: 'Enable/disable persistent file cache for used cli builder',
     },
+    {
+      name: '--https',
+      value: '[https]',
+      transformer: (value: string) => value !== 'false',
+      description: 'Enable/disable https protocol for application',
+    },
+    {
+      name: '--httpsKey',
+      value: '[httpsKey]',
+      description: 'Path to https key certificate',
+    },
+    {
+      name: '--httpsCert',
+      value: '[httpsCert]',
+      description: 'Path to https certificate',
+    },
   ];
 
   alias = 's';

package/src/commands/start-prod/command.ts

@@ -85,6 +85,22 @@ export class StartProdCommand extends CLICommand<Params> {
       transformer: (value: string) => value !== 'false',
       description: 'Enable/disable persistent file cache for used cli builder',
     },
+    {
+      name: '--https',
+      value: '[https]',
+      transformer: (value: string) => value !== 'false',
+      description: 'Enable/disable https protocol for application',
+    },
+    {
+      name: '--httpsKey',
+      value: '[httpsKey]',
+      description: 'Path to https key certificate',
+    },
+    {
+      name: '--httpsCert',
+      value: '[httpsCert]',
+      description: 'Path to https certificate',
+    },
   ];
 
   alias = 'sp';

package/src/commands/static/application.ts

@@ -127,7 +127,9 @@ export const staticApp = async (
     handleServerOutput(context.logger, chunk);
   });
 
-  const readinessProbePath = `http://localhost:${envVariables.UTILITY_SERVER_PORT ?? port}/readyz`;
+  const readinessProbePath = `${clientConfigManager.httpProtocol}://localhost:${
+    envVariables.UTILITY_SERVER_PORT ?? port
+  }/readyz`;
 
   await Promise.race([
     server,