proteum 2.1.8 → 2.1.9-2

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,88 @@ 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 findVisibleNodeModulesRoots = (startPath: string): string[] => {
+    const roots: string[] = [];
+    let currentPath = path.resolve(startPath);
+
+    while (true) {
+        const candidate = path.join(currentPath, 'node_modules');
+        if (fs.existsSync(candidate) && !roots.includes(candidate)) roots.push(candidate);
+
+        const parentPath = path.dirname(currentPath);
+        if (parentPath === currentPath) return roots;
+        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 findVisiblePackageInstalls = (startPath: string, packageName: string): string[] => {
+    const installs: string[] = [];
+    let currentPath = path.resolve(startPath);
+
+    while (true) {
+        const candidate = path.join(currentPath, 'node_modules', packageName);
+        if (fs.existsSync(candidate) && !installs.includes(candidate)) installs.push(candidate);
+
+        const parentPath = path.dirname(currentPath);
+        if (parentPath === currentPath) return installs;
+        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 +163,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 +173,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 +275,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 +369,137 @@ 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] : []),
+            ...this.getVisiblePackageInstallRoots('proteum'),
+        ].filter((rootPath, index, list) => list.indexOf(rootPath) === index && fs.existsSync(rootPath));
+    }
+
+    public getVisibleNodeModulesRootsForPath(startPath: string): string[] {
+        return findVisibleNodeModulesRoots(startPath);
+    }
+
+    public getVisiblePackageInstallRoots(packageName: string, startPath = this.appRoot): string[] {
+        return findVisiblePackageInstalls(startPath, packageName);
+    }
+
+    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 installedRoot = this.framework.installedRoot;
+        const searchPaths = (preferApp
+            ? [this.appRoot, ...(installedRoot ? [installedRoot] : []), this.framework.activeRoot]
+            : [this.framework.activeRoot, ...(installedRoot ? [installedRoot] : []), this.appRoot]
+        ).filter((searchPath, index, list) => list.indexOf(searchPath) === index);
+        return path.dirname(resolvePackageJsonPath(packageName, searchPaths));
+    }
+
+    public resolveRequest(request: string, { preferApp = true }: { preferApp?: boolean } = {}): string {
+        const installedRoot = this.framework.installedRoot;
+        const searchPaths = (preferApp
+            ? [this.appRoot, ...(installedRoot ? [installedRoot] : []), this.framework.activeRoot]
+            : [this.framework.activeRoot, ...(installedRoot ? [installedRoot] : []), this.appRoot]
+        ).filter((searchPath, index, list) => list.indexOf(searchPath) === index);
+        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,18 @@
-const React = require('react') as typeof import('react');
-
+import type { TServerReadyConnectedProject } from '../../common/dev/serverHotReload';
 import { renderRows } from './layout';
-import { renderInk } from './ink';
+import { CliReact, 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 +20,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 +56,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 createElement = CliReact.createElement;
+        const verifiedConnectedProjects = connectedProjects || [];
 
         return createElement(
             Box,
@@ -68,13 +74,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 (/ping): ${formatConnectedProjectLabel(connectedProject)}`,
+                ),
+            ),
             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}`),
@@ -83,7 +96,7 @@ export const renderServerReadyBanner = async ({
 
 export const renderDevShutdownBanner = async () =>
     renderInk(({ Box, Text }) => {
-        const createElement = React.createElement;
+        const createElement = CliReact.createElement;
 
         return createElement(
             Box,

package/cli/presentation/ink.ts

@@ -1,4 +1,4 @@
-const React = require('react') as typeof import('react');
+import { createRequire } from 'module';
 
 import { importEsm } from '../runtime/importEsm';
 import { getTerminalWidth } from './layout';
@@ -13,6 +13,9 @@ type TInkRuntime = {
     StatusMessage: TInkUiModule['StatusMessage'];
 };
 
+// Keep the CLI renderer on the exact React instance Ink resolved for this install shape.
+const CliReact = createRequire(require.resolve('ink'))('react') as typeof import('react');
+
 let inkRuntimePromise: Promise<TInkRuntime> | undefined;
 
 const loadInkRuntime = () => {
@@ -41,7 +44,7 @@ export const renderInk = async (
 
 export const renderTitle = async (title: string, subtitle?: string) =>
     renderInk(({ Box, Text }) => {
-        const createElement = React.createElement;
+        const createElement = CliReact.createElement;
 
         return createElement(
             Box,
@@ -52,18 +55,20 @@ export const renderTitle = async (title: string, subtitle?: string) =>
     });
 
 export const renderSection = async (title: string, body: string) => {
-    const heading = await renderInk(({ Text }) => React.createElement(Text, { bold: true }, title));
+    const heading = await renderInk(({ Text }) => CliReact.createElement(Text, { bold: true }, title));
     return `${heading}\n${body}`;
 };
 
 export const renderStep = async (label: string, message: string) =>
-    renderInk(({ Text }) => React.createElement(Text, { color: 'cyan' }, `${label} ${message}`));
+    renderInk(({ Text }) => CliReact.createElement(Text, { color: 'cyan' }, `${label} ${message}`));
 
 const renderStatusMessage = async (variant: 'success' | 'warning' | 'error', message: string) =>
-    renderInk(({ StatusMessage }) => React.createElement(StatusMessage, { variant }, message));
+    renderInk(({ StatusMessage }) => CliReact.createElement(StatusMessage, { variant }, message));
 
 export const renderSuccess = (message: string) => renderStatusMessage('success', message);
 
 export const renderWarning = (message: string) => renderStatusMessage('warning', message);
 
 export const renderDanger = (message: string) => renderStatusMessage('error', message);
+
+export { CliReact };

package/cli/presentation/welcome.ts

@@ -1,7 +1,5 @@
-const React = require('react') as typeof import('react');
-
 import { renderRows } from './layout';
-import { renderInk } from './ink';
+import { CliReact, renderInk } from './ink';
 
 const ProteumWordmark = [
     String.raw` ____  ____   ___ _____ _____ _   _ __  __`,
@@ -18,14 +16,16 @@ export const clearInteractiveConsole = () => {
 };
 
 export const renderWelcomePanel = async ({
+    installSummary,
     version,
     tagline,
 }: {
+    installSummary?: string;
     version: string;
     tagline: string;
 }) =>
     renderInk(({ Box, Text }) => {
-        const createElement = React.createElement;
+        const createElement = CliReact.createElement;
         const wordmark = ProteumWordmark.map((line) =>
             createElement(Text, { key: line, bold: true, color: 'blue' }, line),
         );
@@ -37,19 +37,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 });