proteum 2.1.7 → 2.1.9

package/cli/runtime/devSessions.ts

@@ -0,0 +1,337 @@
+import path from 'path';
+
+import fs from 'fs-extra';
+
+export const devSessionRegistryVersion = 1 as const;
+
+export type TDevSessionState = 'starting' | 'ready';
+
+export type TDevSessionRecord = {
+    version: typeof devSessionRegistryVersion;
+    pid: number;
+    appRoot: string;
+    routerPort: number;
+    publicUrl: string;
+    startedAt: string;
+    updatedAt: string;
+    sessionFilePath: string;
+    state: TDevSessionState;
+};
+
+export type TDevSessionInspection = {
+    sessionFilePath: string;
+    record: TDevSessionRecord | null;
+    live: boolean;
+    stale: boolean;
+    invalid: boolean;
+    parseError: string;
+};
+
+export type TStopDevSessionResult = {
+    sessionFilePath: string;
+    pid: number | null;
+    routerPort: number | null;
+    publicUrl: string;
+    state: TDevSessionState | '';
+    matched: boolean;
+    stopped: boolean;
+    removed: boolean;
+    stale: boolean;
+    live: boolean;
+    invalid: boolean;
+    parseError: string;
+};
+
+const defaultRegistryDirectoryParts = ['var', 'run', 'proteum', 'dev'];
+
+const sleep = async (durationMs: number) => await new Promise((resolve) => setTimeout(resolve, durationMs));
+
+const isRecordShape = (value: unknown): value is TDevSessionRecord => {
+    if (!value || typeof value !== 'object') return false;
+
+    const candidate = value as Partial<TDevSessionRecord>;
+
+    return (
+        candidate.version === devSessionRegistryVersion &&
+        typeof candidate.pid === 'number' &&
+        Number.isInteger(candidate.pid) &&
+        candidate.pid > 0 &&
+        typeof candidate.appRoot === 'string' &&
+        candidate.appRoot.length > 0 &&
+        typeof candidate.routerPort === 'number' &&
+        Number.isInteger(candidate.routerPort) &&
+        candidate.routerPort > 0 &&
+        typeof candidate.publicUrl === 'string' &&
+        typeof candidate.startedAt === 'string' &&
+        typeof candidate.updatedAt === 'string' &&
+        typeof candidate.sessionFilePath === 'string' &&
+        candidate.sessionFilePath.length > 0 &&
+        (candidate.state === 'starting' || candidate.state === 'ready')
+    );
+};
+
+const canSignalProcess = (pid: number, signal: NodeJS.Signals | 0) => {
+    try {
+        process.kill(pid, signal);
+        return true;
+    } catch (error) {
+        const errno = error as NodeJS.ErrnoException;
+
+        if (errno.code === 'ESRCH') return false;
+        if (errno.code === 'EPERM') return true;
+
+        throw error;
+    }
+};
+
+export const isProcessAlive = (pid: number) => canSignalProcess(pid, 0);
+
+const waitForProcessExit = async (pid: number, timeoutMs: number) => {
+    const deadline = Date.now() + timeoutMs;
+
+    while (Date.now() < deadline) {
+        if (!isProcessAlive(pid)) return true;
+        await sleep(100);
+    }
+
+    return !isProcessAlive(pid);
+};
+
+export const getDevSessionRegistryDirectory = (appRoot: string) => path.join(appRoot, ...defaultRegistryDirectoryParts);
+
+export const resolveDevSessionFilePath = ({
+    appRoot,
+    port,
+    sessionFilePath,
+}: {
+    appRoot: string;
+    port: number;
+    sessionFilePath?: string;
+}) => {
+    if (sessionFilePath && sessionFilePath.trim()) {
+        return path.isAbsolute(sessionFilePath)
+            ? path.normalize(sessionFilePath)
+            : path.resolve(appRoot, sessionFilePath);
+    }
+
+    return path.join(getDevSessionRegistryDirectory(appRoot), `${port}.json`);
+};
+
+export const createDevSessionRecord = ({
+    appRoot,
+    port,
+    sessionFilePath,
+}: {
+    appRoot: string;
+    port: number;
+    sessionFilePath: string;
+}): TDevSessionRecord => {
+    const timestamp = new Date().toISOString();
+
+    return {
+        version: devSessionRegistryVersion,
+        pid: process.pid,
+        appRoot,
+        routerPort: port,
+        publicUrl: '',
+        startedAt: timestamp,
+        updatedAt: timestamp,
+        sessionFilePath,
+        state: 'starting',
+    };
+};
+
+export const writeDevSessionRecord = async (record: TDevSessionRecord) => {
+    await fs.ensureDir(path.dirname(record.sessionFilePath));
+    await fs.writeJson(record.sessionFilePath, record, { spaces: 2 });
+};
+
+export const updateDevSessionRecord = async ({
+    sessionFilePath,
+    patch,
+}: {
+    sessionFilePath: string;
+    patch: Partial<Omit<TDevSessionRecord, 'version' | 'pid' | 'appRoot' | 'routerPort' | 'startedAt' | 'sessionFilePath'>>;
+}) => {
+    const inspection = await inspectDevSessionFile(sessionFilePath);
+    if (!inspection || !inspection.record) return;
+
+    await writeDevSessionRecord({
+        ...inspection.record,
+        ...patch,
+        updatedAt: new Date().toISOString(),
+    });
+};
+
+export const removeDevSessionRecord = async (sessionFilePath: string) => {
+    await fs.remove(sessionFilePath);
+};
+
+export const removeDevSessionRecordSync = (sessionFilePath: string) => {
+    try {
+        fs.removeSync(sessionFilePath);
+    } catch {
+        // Best-effort cleanup during process exit.
+    }
+};
+
+export const inspectDevSessionFile = async (sessionFilePath: string): Promise<TDevSessionInspection | null> => {
+    if (!(await fs.pathExists(sessionFilePath))) return null;
+
+    try {
+        const rawValue = await fs.readJson(sessionFilePath);
+        if (!isRecordShape(rawValue)) {
+            return {
+                sessionFilePath,
+                record: null,
+                live: false,
+                stale: true,
+                invalid: true,
+                parseError: 'Session file contents do not match the Proteum dev session schema.',
+            };
+        }
+
+        const record = rawValue;
+        const live = isProcessAlive(record.pid);
+
+        return {
+            sessionFilePath,
+            record,
+            live,
+            stale: !live,
+            invalid: false,
+            parseError: '',
+        };
+    } catch (error) {
+        return {
+            sessionFilePath,
+            record: null,
+            live: false,
+            stale: true,
+            invalid: true,
+            parseError: error instanceof Error ? error.message : String(error),
+        };
+    }
+};
+
+export const listDevSessionFiles = async ({
+    appRoot,
+    sessionFilePath,
+}: {
+    appRoot: string;
+    sessionFilePath?: string;
+}) => {
+    if (sessionFilePath && sessionFilePath.trim())
+        return [resolveDevSessionFilePath({ appRoot, port: 1, sessionFilePath })];
+
+    const registryDirectory = getDevSessionRegistryDirectory(appRoot);
+    if (!(await fs.pathExists(registryDirectory))) return [];
+
+    const entries = await fs.readdir(registryDirectory);
+
+    return entries
+        .filter((entry) => entry.endsWith('.json'))
+        .sort((left, right) => left.localeCompare(right))
+        .map((entry) => path.join(registryDirectory, entry));
+};
+
+export const listDevSessionInspections = async ({
+    appRoot,
+    sessionFilePath,
+}: {
+    appRoot: string;
+    sessionFilePath?: string;
+}) => {
+    const sessionFilePaths = await listDevSessionFiles({ appRoot, sessionFilePath });
+    const inspections = await Promise.all(sessionFilePaths.map((entryPath) => inspectDevSessionFile(entryPath)));
+
+    return inspections.filter((inspection): inspection is TDevSessionInspection => inspection !== null);
+};
+
+export const stopDevSessionFile = async (sessionFilePath: string): Promise<TStopDevSessionResult> => {
+    const inspection = await inspectDevSessionFile(sessionFilePath);
+
+    if (!inspection) {
+        return {
+            sessionFilePath,
+            pid: null,
+            routerPort: null,
+            publicUrl: '',
+            state: '',
+            matched: false,
+            stopped: false,
+            removed: false,
+            stale: false,
+            live: false,
+            invalid: false,
+            parseError: '',
+        };
+    }
+
+    if (!inspection.record) {
+        await removeDevSessionRecord(sessionFilePath);
+
+        return {
+            sessionFilePath,
+            pid: null,
+            routerPort: null,
+            publicUrl: '',
+            state: '',
+            matched: true,
+            stopped: true,
+            removed: true,
+            stale: true,
+            live: false,
+            invalid: true,
+            parseError: inspection.parseError,
+        };
+    }
+
+    const { record } = inspection;
+
+    if (!inspection.live) {
+        await removeDevSessionRecord(sessionFilePath);
+
+        return {
+            sessionFilePath,
+            pid: record.pid,
+            routerPort: record.routerPort,
+            publicUrl: record.publicUrl,
+            state: record.state,
+            matched: true,
+            stopped: true,
+            removed: true,
+            stale: true,
+            live: false,
+            invalid: false,
+            parseError: '',
+        };
+    }
+
+    if (canSignalProcess(record.pid, 'SIGTERM')) {
+        const exitedAfterTerm = await waitForProcessExit(record.pid, 5000);
+        if (!exitedAfterTerm && canSignalProcess(record.pid, 'SIGKILL')) {
+            await waitForProcessExit(record.pid, 2000);
+        }
+    }
+
+    const live = isProcessAlive(record.pid);
+    if (!live) {
+        await removeDevSessionRecord(sessionFilePath);
+    }
+
+    return {
+        sessionFilePath,
+        pid: record.pid,
+        routerPort: record.routerPort,
+        publicUrl: record.publicUrl,
+        state: record.state,
+        matched: true,
+        stopped: !live,
+        removed: !live,
+        stale: !live,
+        live,
+        invalid: false,
+        parseError: '',
+    };
+};

package/cli/scaffold/index.ts

@@ -26,6 +26,7 @@ import {
     createServiceConfigTemplate,
     createServiceTemplate,
 } from './templates';
+import type { TTsconfigTemplatePaths } from './templates';
 import type { TScaffoldFilePlan, TScaffoldInitConfig, TScaffoldKind, TScaffoldResult } from './types';
 
 type TCreatePlan = {
@@ -602,7 +603,29 @@ const assertInitTarget = ({ appRoot }: { appRoot: string }) => {
     );
 };
 
-const createInitFilePlans = (config: TScaffoldInitConfig): TScaffoldFilePlan[] => [
+const createAppTsconfigTemplatePaths = ({
+    appRoot,
+    side,
+}: {
+    appRoot: string;
+    side: 'client' | 'server';
+}): TTsconfigTemplatePaths => {
+    const tsconfigFilepath = path.join(appRoot, side, 'tsconfig.json');
+
+    return {
+        frameworkTsconfig: cli.paths.relativeFrameworkPathForAppRoot(appRoot, tsconfigFilepath, 'tsconfig.common.json'),
+        frameworkClient: cli.paths.relativeFrameworkPathFromDirectoryForAppRoot(appRoot, appRoot, 'client', '*'),
+        frameworkCommon: cli.paths.relativeFrameworkPathFromDirectoryForAppRoot(appRoot, appRoot, 'common', '*'),
+        frameworkServer: cli.paths.relativeFrameworkPathFromDirectoryForAppRoot(appRoot, appRoot, 'server', '*'),
+        frameworkTypesGlobal: cli.paths.relativeFrameworkPathForAppRoot(appRoot, tsconfigFilepath, 'types', 'global'),
+        preactCompat: cli.paths.relativeAppNodeModulesPathFromDirectoryForAppRoot(appRoot, appRoot, 'preact', 'compat'),
+        preactCompatClient: cli.paths.relativeAppNodeModulesPathFromDirectoryForAppRoot(appRoot, appRoot, 'preact', 'compat', 'client'),
+        preactTestUtils: cli.paths.relativeAppNodeModulesPathFromDirectoryForAppRoot(appRoot, appRoot, 'preact', 'test-utils'),
+        preactJsxRuntime: cli.paths.relativeAppNodeModulesPathFromDirectoryForAppRoot(appRoot, appRoot, 'preact', 'jsx-runtime'),
+    };
+};
+
+const createInitFilePlans = ({ appRoot, config }: { appRoot: string; config: TScaffoldInitConfig }): TScaffoldFilePlan[] => [
     {
         relativePath: 'package.json',
         content: createPackageJsonTemplate({
@@ -643,11 +666,11 @@ const createInitFilePlans = (config: TScaffoldInitConfig): TScaffoldFilePlan[] =
     },
     {
         relativePath: path.join('client', 'tsconfig.json'),
-        content: createClientTsconfigTemplate(),
+        content: createClientTsconfigTemplate(createAppTsconfigTemplatePaths({ appRoot, side: 'client' })),
     },
     {
         relativePath: path.join('server', 'tsconfig.json'),
-        content: createServerTsconfigTemplate(),
+        content: createServerTsconfigTemplate(createAppTsconfigTemplatePaths({ appRoot, side: 'server' })),
     },
     {
         relativePath: path.join('server', 'config', 'app.ts'),
@@ -675,7 +698,7 @@ export const runInitScaffold = async () => {
     assertInitTarget({ appRoot });
 
     const result = createEmptyResult({ dryRun: isDryRun() });
-    const filePlans = createInitFilePlans(config);
+    const filePlans = createInitFilePlans({ appRoot, config });
 
     maybeWriteFilePlans({ rootDir: appRoot, filePlans, result });
 

package/cli/scaffold/templates.ts

@@ -2,6 +2,18 @@ import type { TScaffoldInitConfig, TScaffoldResult } from './types';
 
 const renderJson = (value: unknown) => JSON.stringify(value, null, 4);
 
+export type TTsconfigTemplatePaths = {
+    frameworkTsconfig: string;
+    frameworkClient: string;
+    frameworkCommon: string;
+    frameworkServer: string;
+    frameworkTypesGlobal: string;
+    preactCompat: string;
+    preactCompatClient: string;
+    preactTestUtils: string;
+    preactJsxRuntime: string;
+};
+
 export const createPageTemplate = ({
     routePath,
     heading,
@@ -162,8 +174,8 @@ export default class ${appIdentifier} extends Application {
 }
 `;
 
-export const createClientTsconfigTemplate = () => `{
-    "extends": "../node_modules/proteum/tsconfig.common.json",
+export const createClientTsconfigTemplate = (paths: TTsconfigTemplatePaths) => `{
+    "extends": ${JSON.stringify(paths.frameworkTsconfig)},
     "compilerOptions": {
         "rootDir": "..",
         "baseUrl": "..",
@@ -172,9 +184,9 @@ export const createClientTsconfigTemplate = () => `{
         "strictBindCallApply": true,
         "useUnknownInCatchVariables": true,
         "paths": {
-            "@client/*": ["./node_modules/proteum/client/*"],
-            "@common/*": ["./node_modules/proteum/common/*"],
-            "@server/*": ["./node_modules/proteum/server/*"],
+            "@client/*": [${JSON.stringify(paths.frameworkClient)}],
+            "@common/*": [${JSON.stringify(paths.frameworkCommon)}],
+            "@server/*": [${JSON.stringify(paths.frameworkServer)}],
 
             "@/client/context": ["./.proteum/client/context.ts"],
             "@generated/client/*": ["./.proteum/client/*"],
@@ -182,24 +194,25 @@ export const createClientTsconfigTemplate = () => `{
             "@generated/server/*": ["./.proteum/server/*"],
             "@/*": ["./*"],
 
-            "react": ["./node_modules/preact/compat"],
-            "react-dom/test-utils": ["./node_modules/preact/test-utils"],
-            "react-dom": ["./node_modules/preact/compat"],
-            "react/jsx-runtime": ["./node_modules/preact/jsx-runtime"]
+            "react": [${JSON.stringify(paths.preactCompat)}],
+            "react-dom/client": [${JSON.stringify(paths.preactCompatClient)}],
+            "react-dom/test-utils": [${JSON.stringify(paths.preactTestUtils)}],
+            "react-dom": [${JSON.stringify(paths.preactCompat)}],
+            "react/jsx-runtime": [${JSON.stringify(paths.preactJsxRuntime)}]
         }
     },
     "include": [
         ".",
         "../var/typings",
-        "../node_modules/proteum/types/global",
+        ${JSON.stringify(paths.frameworkTypesGlobal)},
         "../.proteum/client/services.d.ts",
         "../server/index.ts"
     ]
 }
 `;
 
-export const createServerTsconfigTemplate = () => `{
-    "extends": "../node_modules/proteum/tsconfig.common.json",
+export const createServerTsconfigTemplate = (paths: TTsconfigTemplatePaths) => `{
+    "extends": ${JSON.stringify(paths.frameworkTsconfig)},
     "compilerOptions": {
         "rootDir": "..",
         "baseUrl": "..",
@@ -209,9 +222,9 @@ export const createServerTsconfigTemplate = () => `{
         "useUnknownInCatchVariables": true,
         "moduleSuffixes": [".ssr", ""],
         "paths": {
-            "@client/*": ["./node_modules/proteum/client/*"],
-            "@common/*": ["./node_modules/proteum/common/*"],
-            "@server/*": ["./node_modules/proteum/server/*"],
+            "@client/*": [${JSON.stringify(paths.frameworkClient)}],
+            "@common/*": [${JSON.stringify(paths.frameworkCommon)}],
+            "@server/*": [${JSON.stringify(paths.frameworkServer)}],
 
             "@/client/context": ["./.proteum/client/context.ts"],
             "@generated/client/*": ["./.proteum/client/*"],
@@ -219,10 +232,11 @@ export const createServerTsconfigTemplate = () => `{
             "@generated/server/*": ["./.proteum/server/*"],
             "@/*": ["./*"],
 
-            "react": ["./node_modules/preact/compat"],
-            "react-dom/test-utils": ["./node_modules/preact/test-utils"],
-            "react-dom": ["./node_modules/preact/compat"],
-            "react/jsx-runtime": ["./node_modules/preact/jsx-runtime"]
+            "react": [${JSON.stringify(paths.preactCompat)}],
+            "react-dom/client": [${JSON.stringify(paths.preactCompatClient)}],
+            "react-dom/test-utils": [${JSON.stringify(paths.preactTestUtils)}],
+            "react-dom": [${JSON.stringify(paths.preactCompat)}],
+            "react/jsx-runtime": [${JSON.stringify(paths.preactJsxRuntime)}]
         }
     },
     "include": [
@@ -230,7 +244,7 @@ export const createServerTsconfigTemplate = () => `{
         "../identity.config.ts",
         "../proteum.config.ts",
         "../var/typings",
-        "../node_modules/proteum/types/global",
+        ${JSON.stringify(paths.frameworkTypesGlobal)},
         "../.proteum/server/services.d.ts",
         "../server/index.ts"
     ]

package/cli/utils/check.ts

@@ -8,13 +8,7 @@ import { runProcess } from './runProcess';
 const tsconfigPaths = ['client/tsconfig.json', 'server/tsconfig.json', 'commands/tsconfig.json'];
 const eslintConfigPaths = ['eslint.config.mjs', 'eslint.config.js', 'eslint.config.cjs'];
 
-const resolveInstalledBinary = (name: string) => {
-    const binary = path.join(cli.paths.core.root, 'node_modules', '.bin', name);
-
-    if (!fs.existsSync(binary)) throw new Error(`Missing required binary "${name}" in Proteum dependencies.`);
-
-    return binary;
-};
+const resolveInstalledBinary = (packageName: string, binName: string) => cli.paths.resolveBinary(packageName, binName);
 
 const resolveExistingAppPaths = (paths: string[]) =>
     paths
@@ -43,10 +37,10 @@ export const runAppTypecheck = async () => {
     if (existingProjects.length === 0)
         throw new Error(`No TypeScript app projects found. Expected one of: ${tsconfigPaths.join(', ')}.`);
 
-    const tsc = resolveInstalledBinary('tsc');
+    const tsc = resolveInstalledBinary('typescript', 'tsc');
 
     for (const { relativePath } of existingProjects)
-        await runProcess(tsc, ['-p', relativePath, '--noEmit', '--pretty', 'false'], {
+        await runProcess(tsc.command, [...tsc.args, '-p', relativePath, '--noEmit', '--pretty', 'false'], {
             cwd: cli.paths.appRoot,
             env: getTypecheckEnv(),
         });
@@ -62,10 +56,10 @@ export const runAppLint = async ({ fix = false } = {}) => {
                 .join(', ')}.`,
         );
 
-    const eslint = resolveInstalledBinary('eslint');
+    const eslint = resolveInstalledBinary('eslint', 'eslint');
     const args = ['.', '--config', config.absolutePath, '--no-config-lookup'];
 
     if (fix) args.push('--fix');
 
-    await runProcess(eslint, args, { cwd: cli.paths.appRoot });
+    await runProcess(eslint.command, [...eslint.args, ...args], { cwd: cli.paths.appRoot });
 };

package/client/app/index.ts

@@ -41,6 +41,18 @@ type Prettify<T> = { [K in keyof T]: T[K] } & {};
 
 export type ApplicationProperties = Prettify<keyof Application>;
 
+const normalizeBrowserErrorMessage = (value: unknown): string => {
+    if (typeof value === 'string') return value;
+    if (value && typeof value === 'object' && 'message' in value && typeof value.message === 'string')
+        return value.message;
+
+    return '';
+};
+
+const isIgnorableBrowserErrorMessage = (message: string) =>
+    message === 'ResizeObserver loop completed with undelivered notifications.' ||
+    message === 'ResizeObserver loop limit exceeded';
+
 /*----------------------------------
 - CLASS
 ----------------------------------*/
@@ -81,8 +93,11 @@ export default abstract class Application {
         });
 
         window.onerror = (message, file, line, col, stacktrace) => {
-            console.error(`Exception catched by method B`, message);
-            this.reportBug({ stacktrace: stacktrace?.stack || JSON.stringify({ message, file, line, col }) }).then(
+            const normalizedMessage = normalizeBrowserErrorMessage(message);
+            if (isIgnorableBrowserErrorMessage(normalizedMessage)) return true;
+
+            console.error(`Exception catched by method B`, normalizedMessage || message);
+            this.reportBug({ stacktrace: stacktrace?.stack || JSON.stringify({ message: normalizedMessage || message, file, line, col }) }).then(
                 () => {
                     // TODO in toas service: app.on('bug', () => toast.warning( ... ))
                     /*context?.toast.warning("Bug detected", 

package/client/app.tsconfig.json

@@ -1,28 +1,29 @@
 {
-    "extends": "../../node_modules/proteum/tsconfig.common.json",
+    "extends": "../tsconfig.common.json",
     "compilerOptions": {
         "rootDir": "..",
         "baseUrl": "..",
         "paths": {
             
-            "@client/*": ["../node_modules/proteum/client/*"],
-            "@common/*": ["../node_modules/proteum/common/*"],
+            "@client/*": ["./client/*"],
+            "@common/*": ["./common/*"],
 
             // Only used for typings (ex: ServerResponse)
             // Removed before bundling
-            "@server/*": ["../node_modules/proteum/server/*"],
+            "@server/*": ["./server/*"],
             "@/*": ["./*"],
 
             // ATTENTION: Les références à preact doivent toujours pointer vers la même instance
-            "react": ["preact/compat"],
-            "react-dom/test-utils": ["preact/test-utils"],
-            "react-dom": ["preact/compat"], // Must be below test-utils
-            "react/jsx-runtime": ["preact/jsx-runtime"],
-            "preact/jsx-runtime": ["preact/jsx-runtime"]
+            "react": ["../preact/compat"],
+            "react-dom/client": ["../preact/compat/client"],
+            "react-dom/test-utils": ["../preact/test-utils"],
+            "react-dom": ["../preact/compat"], // Must be below client + test-utils
+            "react/jsx-runtime": ["../preact/jsx-runtime"],
+            "preact/jsx-runtime": ["../preact/jsx-runtime"]
         }
     },
     "include": [
         ".",
-        "../../node_modules/proteum/types/global"
+        "../types/global"
     ]
 }

package/common/connectedProjects.ts

@@ -44,6 +44,13 @@ export type TConnectedProjectEnvConfig = {
     urlInternal: string;
 };
 
+export type TConnectedProjectHealthResponse = {
+    connectedProjects: string[];
+    identifier: string;
+    name: string;
+    ok: true;
+};
+
 export type TConnectedFetcherTarget = {
     namespace: string;
     controllerAccessor: string;

package/common/dev/serverHotReload.ts

@@ -13,9 +13,18 @@ export type TServerHotReloadResult = {
     error?: string;
 };
 
+export type TServerReadyConnectedProject = {
+    namespace: string;
+    identifier: string;
+    name: string;
+    urlInternal: string;
+    healthUrl: string;
+};
+
 export type TServerReadyMessage = {
     type: typeof serverHotReloadMessageType.ready;
     publicUrl: string;
+    connectedProjects?: TServerReadyConnectedProject[];
 };
 
 export const isServerHotReloadRequest = (value: unknown): value is TServerHotReloadRequest =>
@@ -31,8 +40,20 @@ export const isServerHotReloadResult = (value: unknown): value is TServerHotRelo
         (value as TServerHotReloadResult).type === serverHotReloadMessageType.failed) &&
     Array.isArray((value as TServerHotReloadResult).changedFiles);
 
+const isServerReadyConnectedProject = (value: unknown): value is TServerReadyConnectedProject =>
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as TServerReadyConnectedProject).namespace === 'string' &&
+    typeof (value as TServerReadyConnectedProject).identifier === 'string' &&
+    typeof (value as TServerReadyConnectedProject).name === 'string' &&
+    typeof (value as TServerReadyConnectedProject).urlInternal === 'string' &&
+    typeof (value as TServerReadyConnectedProject).healthUrl === 'string';
+
 export const isServerReadyMessage = (value: unknown): value is TServerReadyMessage =>
     typeof value === 'object' &&
     value !== null &&
     (value as TServerReadyMessage).type === serverHotReloadMessageType.ready &&
-    typeof (value as TServerReadyMessage).publicUrl === 'string';
+    typeof (value as TServerReadyMessage).publicUrl === 'string' &&
+    ((value as TServerReadyMessage).connectedProjects === undefined ||
+        (Array.isArray((value as TServerReadyMessage).connectedProjects) &&
+            (value as TServerReadyMessage).connectedProjects.every(isServerReadyConnectedProject)));