proteum 2.1.8 → 2.1.9

package/cli/paths.ts

@@ -35,6 +35,29 @@ export type TPathInfos = {
     isIndex: boolean;
 };
 
+export type TResolvedPackageBinary = {
+    packageName: string;
+    packageRoot: string;
+    binPath: string;
+    command: string;
+    args: string[];
+};
+
+export type TFrameworkInstallGraph = {
+    activeRoot: string;
+    installedRoot?: string;
+    appNodeModulesRoot: string;
+    frameworkNodeModulesRoot: string;
+};
+
+export type TFrameworkInstallMode = 'npm' | 'npm-link' | 'path' | 'workspace' | 'global' | 'checkout';
+
+export type TFrameworkInstallInfo = {
+    mode: TFrameworkInstallMode;
+    summary: string;
+    dependencySpec?: string;
+};
+
 /*----------------------------------
 - CONFIG
 ----------------------------------*/
@@ -51,7 +74,60 @@ const safeRealpath = (filepath: string) => {
     }
 };
 
-const resolveCoreRoot = (appRoot: string) => {
+const readPackageJson = (filepath: string) => {
+    try {
+        return JSON.parse(fs.readFileSync(filepath, 'utf8')) as Record<string, unknown>;
+    } catch {
+        return undefined;
+    }
+};
+
+const readPackageDependencySpec = (appRoot: string, packageName: string) => {
+    const packageJson = readPackageJson(path.join(appRoot, 'package.json'));
+    if (!packageJson) return undefined;
+
+    const dependencySections = ['dependencies', 'devDependencies', 'optionalDependencies', 'peerDependencies'] as const;
+
+    for (const section of dependencySections) {
+        const dependencies = packageJson[section];
+        if (!dependencies || typeof dependencies !== 'object' || Array.isArray(dependencies)) continue;
+
+        const dependencySpec = (dependencies as Record<string, unknown>)[packageName];
+        if (typeof dependencySpec !== 'string' || dependencySpec.trim() === '') continue;
+
+        return dependencySpec.trim();
+    }
+
+    return undefined;
+};
+
+const findVisibleNodeModulesRoot = (startPath: string): string | undefined => {
+    let currentPath = path.resolve(startPath);
+
+    while (true) {
+        const candidate = path.join(currentPath, 'node_modules');
+        if (fs.existsSync(candidate)) return candidate;
+
+        const parentPath = path.dirname(currentPath);
+        if (parentPath === currentPath) return undefined;
+        currentPath = parentPath;
+    }
+};
+
+const findVisiblePackageInstall = (startPath: string, packageName: string): string | undefined => {
+    let currentPath = path.resolve(startPath);
+
+    while (true) {
+        const candidate = path.join(currentPath, 'node_modules', packageName);
+        if (fs.existsSync(candidate)) return candidate;
+
+        const parentPath = path.dirname(currentPath);
+        if (parentPath === currentPath) return undefined;
+        currentPath = parentPath;
+    }
+};
+
+const resolveCoreRoot = (appRoot: string): string => {
     const currentPackageRoot = path.resolve(__dirname, '..');
     const currentBin = path.join(currentPackageRoot, 'cli', 'bin.js');
     const invokedScript = process.argv[1] ? safeRealpath(process.argv[1]) : '';
@@ -59,8 +135,8 @@ const resolveCoreRoot = (appRoot: string) => {
 
     if (invokedCurrentPackage) return currentPackageRoot;
 
-    const localInstall = path.join(appRoot, 'node_modules', 'proteum');
-    if (fs.existsSync(localInstall)) return localInstall;
+    const installedFrameworkRoot = findVisiblePackageInstall(appRoot, 'proteum');
+    if (installedFrameworkRoot) return installedFrameworkRoot;
 
     // When running `npx`/global installs, there may be no local `node_modules/proteum` yet.
     // Fall back to the installed package root (this file lives in `<root>/cli`).
@@ -69,9 +145,101 @@ const resolveCoreRoot = (appRoot: string) => {
 
 const normalizeImportPath = (value: string) => value.replace(/\\/g, '/');
 
+const resolveAppNodeModulesRoot = (appRoot: string): string => {
+    const installedRoot = findVisiblePackageInstall(appRoot, 'proteum');
+
+    return (
+        (installedRoot ? path.dirname(installedRoot) : undefined) ||
+        findVisibleNodeModulesRoot(appRoot) ||
+        path.join(appRoot, 'node_modules')
+    );
+};
+
+const resolveFrameworkInstallRoot = (appRoot: string): string =>
+    findVisiblePackageInstall(appRoot, 'proteum') || path.join(resolveAppNodeModulesRoot(appRoot), 'proteum');
+
+const resolveFrameworkInstallGraph = (appRoot: string, activeRoot: string): TFrameworkInstallGraph => {
+    const installedRoot = findVisiblePackageInstall(appRoot, 'proteum');
+
+    return {
+        activeRoot,
+        installedRoot,
+        appNodeModulesRoot: resolveAppNodeModulesRoot(appRoot),
+        frameworkNodeModulesRoot: findVisibleNodeModulesRoot(activeRoot) || path.join(activeRoot, 'node_modules'),
+    };
+};
+
+const resolvePackageJsonPath = (packageName: string, searchPaths: string[]): string =>
+    require.resolve(`${packageName}/package.json`, { paths: searchPaths });
+
 const filenameToImportName = (value: string) =>
     normalizeImportPath(value).replace(/[^A-Za-z0-9_]+/g, '_');
 
+export const resolveFrameworkInstallInfo = ({
+    appRoot,
+    framework,
+}: {
+    appRoot: string;
+    framework: TFrameworkInstallGraph;
+}): TFrameworkInstallInfo => {
+    const dependencySpec = readPackageDependencySpec(appRoot, 'proteum');
+    const installedRoot = framework.installedRoot ? path.resolve(framework.installedRoot) : undefined;
+    const normalizedActiveRoot = normalizeImportPath(safeRealpath(framework.activeRoot));
+    const installedRootIsSymlink =
+        installedRoot !== undefined &&
+        (() => {
+            try {
+                return fs.lstatSync(installedRoot).isSymbolicLink();
+            } catch {
+                return false;
+            }
+        })();
+
+    if (dependencySpec?.startsWith('file:') || dependencySpec?.startsWith('link:')) {
+        return {
+            mode: 'path',
+            summary: `path (${dependencySpec})`,
+            dependencySpec,
+        };
+    }
+
+    if (dependencySpec?.startsWith('workspace:')) {
+        return {
+            mode: 'workspace',
+            summary: `workspace (${dependencySpec})`,
+            dependencySpec,
+        };
+    }
+
+    if (installedRootIsSymlink) {
+        return {
+            mode: 'npm-link',
+            summary: 'npm link',
+            dependencySpec,
+        };
+    }
+
+    if (dependencySpec) {
+        return {
+            mode: 'npm',
+            summary: `npm (${dependencySpec})`,
+            dependencySpec,
+        };
+    }
+
+    if (!normalizedActiveRoot.includes('/node_modules/')) {
+        return {
+            mode: 'checkout',
+            summary: 'local checkout',
+        };
+    }
+
+    return {
+        mode: 'global',
+        summary: 'global install',
+    };
+};
+
 /*----------------------------------
 - LIB
 ----------------------------------*/
@@ -79,13 +247,15 @@ export default class Paths {
     /*----------------------------------
     - LISTE
     ----------------------------------*/
-
-    public constructor(
-        public appRoot: string,
-        public coreRoot = resolveCoreRoot(appRoot),
-    ) {}
-
-    public core = { cli: path.resolve(__dirname, '.'), root: this.coreRoot, pages: this.coreRoot + '/client/pages' };
+    public coreRoot: string;
+    public framework: TFrameworkInstallGraph;
+    public core: { cli: string; root: string; pages: string };
+
+    public constructor(public appRoot: string, coreRoot = resolveCoreRoot(appRoot)) {
+        this.coreRoot = coreRoot;
+        this.framework = resolveFrameworkInstallGraph(appRoot, coreRoot);
+        this.core = { cli: path.resolve(__dirname, '.'), root: this.coreRoot, pages: this.coreRoot + '/client/pages' };
+    }
 
     /*----------------------------------
     - EXTRACTION
@@ -171,4 +341,124 @@ export default class Paths {
         //console.log('Applying Aliases ...', aliases.forModuleAlias());
         moduleAlias.addAliases(aliases.forModuleAlias());
     }
+
+    public getFrameworkRoots(): string[] {
+        return [
+            this.framework.activeRoot,
+            ...(this.framework.installedRoot ? [this.framework.installedRoot] : []),
+        ].filter((rootPath, index, list) => list.indexOf(rootPath) === index && fs.existsSync(rootPath));
+    }
+
+    public getFrameworkInstallRoot(): string {
+        return this.getFrameworkInstallRootForAppRoot(this.appRoot);
+    }
+
+    public getFrameworkInstallRootForAppRoot(appRoot: string): string {
+        return resolveFrameworkInstallRoot(appRoot);
+    }
+
+    public getAppNodeModulesRootForAppRoot(appRoot: string): string {
+        return resolveAppNodeModulesRoot(appRoot);
+    }
+
+    public relativePathFromFile(targetFile: string, absolutePath: string): string {
+        return this.relativePathFromDirectory(path.dirname(targetFile), absolutePath);
+    }
+
+    public relativePathFromDirectory(targetDirectory: string, absolutePath: string): string {
+        const relativePath = normalizeImportPath(path.relative(targetDirectory, absolutePath));
+        if (relativePath === '') return '.';
+        if (!relativePath.startsWith('.')) return `./${relativePath}`;
+        return relativePath;
+    }
+
+    public relativeFrameworkPathFrom(targetFile: string, ...segments: string[]): string {
+        return this.relativePathFromFile(targetFile, path.join(this.getFrameworkInstallRoot(), ...segments));
+    }
+
+    public relativeAppNodeModulesPathFrom(targetFile: string, ...segments: string[]): string {
+        return this.relativePathFromFile(targetFile, path.join(this.framework.appNodeModulesRoot, ...segments));
+    }
+
+    public relativeFrameworkPathFromDirectory(targetDirectory: string, ...segments: string[]): string {
+        return this.relativePathFromDirectory(targetDirectory, path.join(this.getFrameworkInstallRoot(), ...segments));
+    }
+
+    public relativeAppNodeModulesPathFromDirectory(targetDirectory: string, ...segments: string[]): string {
+        return this.relativePathFromDirectory(targetDirectory, path.join(this.framework.appNodeModulesRoot, ...segments));
+    }
+
+    public relativeFrameworkTsconfigPathFrom(targetFile: string): string {
+        return this.relativeFrameworkPathFrom(targetFile, 'tsconfig.common.json');
+    }
+
+    public relativeFrameworkPathForAppRoot(appRoot: string, targetFile: string, ...segments: string[]): string {
+        return this.relativePathFromFile(targetFile, path.join(this.getFrameworkInstallRootForAppRoot(appRoot), ...segments));
+    }
+
+    public relativeFrameworkPathFromDirectoryForAppRoot(
+        appRoot: string,
+        targetDirectory: string,
+        ...segments: string[]
+    ): string {
+        return this.relativePathFromDirectory(
+            targetDirectory,
+            path.join(this.getFrameworkInstallRootForAppRoot(appRoot), ...segments),
+        );
+    }
+
+    public relativeAppNodeModulesPathFromDirectoryForAppRoot(
+        appRoot: string,
+        targetDirectory: string,
+        ...segments: string[]
+    ): string {
+        return this.relativePathFromDirectory(
+            targetDirectory,
+            path.join(this.getAppNodeModulesRootForAppRoot(appRoot), ...segments),
+        );
+    }
+
+    public resolvePackageRoot(packageName: string, { preferApp = true }: { preferApp?: boolean } = {}): string {
+        const searchPaths = preferApp
+            ? [this.appRoot, this.framework.activeRoot]
+            : [this.framework.activeRoot, this.appRoot];
+        return path.dirname(resolvePackageJsonPath(packageName, searchPaths));
+    }
+
+    public resolveRequest(request: string, { preferApp = true }: { preferApp?: boolean } = {}): string {
+        const searchPaths = preferApp
+            ? [this.appRoot, this.framework.activeRoot]
+            : [this.framework.activeRoot, this.appRoot];
+        return require.resolve(request, { paths: searchPaths });
+    }
+
+    public resolveBinary(
+        packageName: string,
+        binName = packageName,
+        { preferApp = true }: { preferApp?: boolean } = {},
+    ): TResolvedPackageBinary {
+        const packageRoot = this.resolvePackageRoot(packageName, { preferApp });
+        const packageJson = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8')) as {
+            bin?: string | Record<string, string>;
+        };
+        const binField = packageJson.bin;
+        const relativeBinPath =
+            typeof binField === 'string'
+                ? binField
+                : binField?.[binName] || binField?.[packageName];
+
+        if (!relativeBinPath) {
+            throw new Error(`Unable to resolve binary "${binName}" from package "${packageName}".`);
+        }
+
+        const binPath = path.resolve(packageRoot, relativeBinPath);
+
+        return {
+            packageName,
+            packageRoot,
+            binPath,
+            command: process.execPath,
+            args: [binPath],
+        };
+    }
 }

package/cli/presentation/devSession.ts

@@ -1,15 +1,20 @@
 const React = require('react') as typeof import('react');
 
+import type { TServerReadyConnectedProject } from '../../common/dev/serverHotReload';
 import { renderRows } from './layout';
 import { renderInk } from './ink';
 import { renderWelcomePanel } from './welcome';
 
+const formatConnectedProjectLabel = (connectedProject: TServerReadyConnectedProject) =>
+    `${connectedProject.namespace} -> ${connectedProject.name}`;
+
 export const renderDevSession = async ({
     appName,
     appRoot,
     routerPort,
     devEventPort,
     connectedProjects,
+    proteumInstallSummary,
     proteumVersion,
 }: {
     appName: string;
@@ -17,10 +22,12 @@ export const renderDevSession = async ({
     routerPort: number;
     devEventPort: number;
     connectedProjects?: Array<{ namespace: string; urlInternal: string }>;
+    proteumInstallSummary?: string;
     proteumVersion: string;
 }) =>
     [
         await renderWelcomePanel({
+            installSummary: proteumInstallSummary,
             version: proteumVersion,
             tagline: 'Agent-first SSR compiler and server loop.',
         }),
@@ -51,15 +58,16 @@ export const renderServerReadyBanner = async ({
     appName,
     publicUrl,
     routerPort,
-    connectedProjectsCount,
+    connectedProjects,
 }: {
     appName: string;
     publicUrl: string;
     routerPort: number;
-    connectedProjectsCount?: number;
+    connectedProjects?: TServerReadyConnectedProject[];
 }) =>
     renderInk(({ Box, Text }) => {
         const createElement = React.createElement;
+        const verifiedConnectedProjects = connectedProjects || [];
 
         return createElement(
             Box,
@@ -68,13 +76,20 @@ export const renderServerReadyBanner = async ({
             createElement(Text, { bold: true, color: 'green' }, appName),
             createElement(Text, { bold: true }, publicUrl),
             createElement(Text, { dimColor: true }, 'SSR server is listening for requests and hot reloads.'),
-            connectedProjectsCount
+            verifiedConnectedProjects.length > 0
                 ? createElement(
                       Text,
                       { dimColor: true },
-                      `Connected projects: ${connectedProjectsCount}`,
+                      `Connected apps: ${verifiedConnectedProjects.map((connectedProject) => formatConnectedProjectLabel(connectedProject)).join(', ')}`,
                   )
                 : null,
+            ...verifiedConnectedProjects.map((connectedProject) =>
+                createElement(
+                    Text,
+                    { key: `connected-ping-${connectedProject.namespace}`, dimColor: true },
+                    `Ping OK: ${formatConnectedProjectLabel(connectedProject)} responded to /api/__proteum/connected/ping`,
+                ),
+            ),
             createElement(Text, { dimColor: true }, `Diagnose /: proteum diagnose / --port ${routerPort}`),
             createElement(Text, { dimColor: true }, `Perf top: proteum perf top --port ${routerPort}`),
             createElement(Text, { dimColor: true }, `Trace latest: proteum trace latest --port ${routerPort}`),

package/cli/presentation/welcome.ts

@@ -18,9 +18,11 @@ export const clearInteractiveConsole = () => {
 };
 
 export const renderWelcomePanel = async ({
+    installSummary,
     version,
     tagline,
 }: {
+    installSummary?: string;
     version: string;
     tagline: string;
 }) =>
@@ -37,19 +39,23 @@ export const renderWelcomePanel = async ({
             createElement(Text, { bold: true, backgroundColor: 'blue', color: 'white' }, ' WELCOME TO '),
             createElement(Box, { flexDirection: 'column' }, ...wordmark),
             versionLabel ? createElement(Text, { bold: true, color: 'blue' }, versionLabel) : null,
+            installSummary ? createElement(Text, { dimColor: true }, `Installed via ${installSummary}`) : null,
             createElement(Text, { dimColor: true }, tagline),
         );
     });
 
 export const renderCliWelcomeBanner = async ({
     command,
+    installSummary,
     version,
 }: {
     command: string;
+    installSummary?: string;
     version: string;
 }) =>
     [
         await renderWelcomePanel({
+            installSummary,
             version,
             tagline: 'Explicit SSR / SEO / TypeScript framework for agent-friendly apps.',
         }),

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 });
 };