extension-create 3.5.0-next.2 → 3.5.0-next.20

package/dist/lib/install-runner.d.ts

@@ -0,0 +1,10 @@
+type InstallResult = {
+    code: number | null;
+    stderr: string;
+    stdout: string;
+};
+export declare function runInstall(command: string, args: string[], opts: {
+    cwd: string;
+    stdio: 'inherit' | 'ignore' | 'pipe';
+}): Promise<InstallResult>;
+export {};

package/dist/lib/messages.d.ts

@@ -16,6 +16,9 @@ export declare function initializingGitForRepositoryFailed(gitCommand: string, g
 export declare function initializingGitForRepositoryProcessError(projectName: string, error: any): string;
 export declare function initializingGitForRepositoryError(projectName: string, error: any): string;
 export declare function installingDependencies(): string;
+export declare function installingBuildDependencies(dependencies: string[]): string;
+export declare function foundSpecializedDependencies(count: number): string;
+export declare function installingProjectIntegrations(integrations: string[]): string[];
 export declare function installingDependenciesFailed(gitCommand: string, gitArgs: string[], code: number | null): string;
 export declare function installingDependenciesProcessError(projectName: string, error: any): string;
 export declare function cantInstallDependencies(projectName: string, error: any): string;

package/dist/lib/progress.d.ts

@@ -2,6 +2,7 @@ type ProgressOptions = {
     enabled?: boolean;
     intervalMs?: number;
     width?: number;
+    persistLabel?: boolean;
 };
 type ProgressHandle = {
     stop: () => void;

package/dist/module.cjs

@@ -143,6 +143,30 @@ function initializingGitForRepositoryProcessError(projectName, error) {
 function initializingGitForRepositoryError(projectName, error) {
     return `${external_pintor_default().red('Error')} Couldn't initialize ${external_pintor_default().yellow('git')} for ${external_pintor_default().blue(projectName)}.\n${external_pintor_default().red(String(error?.message || error))}\n${external_pintor_default().red('Next step: retry initialization or create the repository manually.')}`;
 }
+function installingDependencies() {
+    return `${statusPrefix} Installing project-specific dependencies...`;
+}
+function installingBuildDependencies(dependencies) {
+    return `${statusPrefix} Installing general build dependencies...`;
+}
+function foundSpecializedDependencies(count) {
+    return `${statusPrefix} Found ${external_pintor_default().yellow(String(count))} specialized dependencies needing installation...`;
+}
+function installingProjectIntegrations(integrations) {
+    if (0 === integrations.length) return [
+        `${statusPrefix} Installing specialized dependencies for ${external_pintor_default().gray('project tooling')}...`
+    ];
+    return integrations.map((integration)=>`${statusPrefix} Installing specialized dependencies for ${external_pintor_default().yellow(integration)}...`);
+}
+function installingDependenciesFailed(gitCommand, gitArgs, code) {
+    return `${external_pintor_default().red('Error')} Command ${external_pintor_default().yellow(gitCommand)} ${external_pintor_default().yellow(gitArgs.join(' '))} failed.\n${external_pintor_default().red(`Exit code: ${external_pintor_default().yellow(String(code))}`)}\n${external_pintor_default().red('Next step: run the command manually to inspect the error.')}`;
+}
+function installingDependenciesProcessError(projectName, error) {
+    return `${external_pintor_default().red('Error')} Child process failed while installing dependencies for ${external_pintor_default().blue(projectName)}.\n${external_pintor_default().red(String(error))}\n${external_pintor_default().red('Next step: run the install command manually to inspect the error.')}`;
+}
+function cantInstallDependencies(projectName, error) {
+    return `${external_pintor_default().red('Error')} Couldn't install dependencies for ${external_pintor_default().blue(projectName)}.\n${external_pintor_default().red(String(error?.message || error))}\n${external_pintor_default().red('Next step: check your package manager settings, then try again.')}`;
+}
 function writingPackageJsonMetadata() {
     return `${statusPrefix} Writing ${external_pintor_default().yellow('package.json')}...`;
 }
@@ -330,7 +354,7 @@ async function importExternalTemplate(projectPath, projectName, template) {
                     if (!line) return false;
                     const trimmed = line.trim();
                     if (!trimmed) return false;
-                    if (/Using git version/i.test(line) || /GitHub API rate limit reached, continuing without connectivity check/i.test(line) || /\[go-git-it\] An error occurred: Error: Failed to download release asset: HTTP 404/i.test(line) || /^Downloading extension\b/i.test(trimmed) || /^URL https?:\/\/codeload\.github\.com\/extension-js\/examples\/zip\/refs\/heads\/main\b/i.test(trimmed) || /^\[[=\s]+\]\s*\d+%/i.test(trimmed)) {
+                    if (/Using git version/i.test(line) || /GitHub API rate limit reached, continuing without connectivity check/i.test(line) || /^Downloading extension\b/i.test(trimmed) || /^URL https?:\/\/codeload\.github\.com\/extension-js\/examples\/zip\/refs\/heads\/main\b/i.test(trimmed) || /^\[[=\s]+\]\s*\d+%/i.test(trimmed)) {
                         suppressGoGitItStack = true;
                         return true;
                     }
@@ -478,6 +502,198 @@ async function overridePackageJson(projectPath, projectName, { template: _templa
         throw error;
     }
 }
+function stripAnsi(input) {
+    return input.replace(/\x1b\[[0-9;]*m/g, '');
+}
+function shouldShowProgress() {
+    return Boolean(process.stdout.isTTY) && !process.env.CI;
+}
+function startProgressBar(label, options) {
+    const enabled = (options?.enabled ?? true) && shouldShowProgress();
+    if (!enabled) return {
+        stop: ()=>void 0
+    };
+    const width = Math.max(10, options?.width ?? 24);
+    const intervalMs = Math.max(50, options?.intervalMs ?? 90);
+    let tick = 0;
+    let lastVisibleLength = 0;
+    const render = ()=>{
+        const filled = tick % (width + 1);
+        const empty = width - filled;
+        const bar = `[${'='.repeat(filled)}${' '.repeat(empty)}]`;
+        const line = `${label} ${bar}`;
+        lastVisibleLength = stripAnsi(line).length;
+        process.stdout.write(`\r${line}`);
+        tick = (tick + 1) % (width + 1);
+    };
+    render();
+    const timer = setInterval(render, intervalMs);
+    return {
+        stop: ()=>{
+            clearInterval(timer);
+            if (process.stdout.isTTY) {
+                process.stdout.write(`\r${' '.repeat(lastVisibleLength)}\r`);
+                if (options?.persistLabel) process.stdout.write(`${label}\n`);
+            }
+        }
+    };
+}
+const external_cross_spawn_namespaceObject = require("cross-spawn");
+function resolveWindowsCmdExe() {
+    const comspec = process.env.ComSpec;
+    if (comspec) return comspec;
+    const systemRoot = process.env.SystemRoot || 'C:\\Windows';
+    return external_path_namespaceObject.join(systemRoot, 'System32', 'cmd.exe');
+}
+function formatCmdArgs(command, args) {
+    const quotedCommand = command.includes(' ') ? `"${command}"` : command;
+    const quotedArgs = args.map((arg)=>arg.includes(' ') ? `"${arg}"` : arg);
+    return `${quotedCommand} ${quotedArgs.join(' ')}`.trim();
+}
+function resolveInstallInvocation(command, args) {
+    if ('win32' !== process.platform) return {
+        command,
+        args
+    };
+    return {
+        command: resolveWindowsCmdExe(),
+        args: [
+            '/d',
+            '/s',
+            '/c',
+            formatCmdArgs(command, args)
+        ]
+    };
+}
+function buildExecEnv() {
+    if ('win32' !== process.platform) return;
+    const nodeDir = external_path_namespaceObject.dirname(process.execPath);
+    const pathSep = external_path_namespaceObject.delimiter;
+    const existing = process.env.PATH || process.env.Path || '';
+    if (existing.includes(nodeDir)) return;
+    return {
+        ...process.env,
+        PATH: `${nodeDir}${pathSep}${existing}`.trim(),
+        Path: `${nodeDir}${pathSep}${existing}`.trim()
+    };
+}
+async function runInstall(command, args, opts) {
+    const invocation = resolveInstallInvocation(command, args);
+    const env = buildExecEnv();
+    const child = (0, external_cross_spawn_namespaceObject.spawn)(invocation.command, invocation.args, {
+        stdio: opts.stdio,
+        cwd: opts.cwd,
+        env: env || process.env
+    });
+    let stdout = '';
+    let stderr = '';
+    if (child.stdout) child.stdout.on('data', (chunk)=>{
+        stdout += chunk.toString();
+    });
+    if (child.stderr) child.stderr.on('data', (chunk)=>{
+        stderr += chunk.toString();
+    });
+    return new Promise((resolve, reject)=>{
+        child.on('close', (code)=>{
+            resolve({
+                code,
+                stderr,
+                stdout
+            });
+        });
+        child.on('error', (error)=>{
+            reject(error);
+        });
+    });
+}
+function getInstallArgs() {
+    return [
+        'install',
+        '--silent'
+    ];
+}
+function getTagFallback(version) {
+    if ('*' === version || 'latest' === version || 'next' === version) return null;
+    const cleaned = version.replace(/^[~^]/, '');
+    return cleaned.includes('-') ? 'next' : 'latest';
+}
+async function updateExtensionDependencyTag(projectPath, projectName) {
+    const packageJsonPath = external_path_namespaceObject.join(projectPath, 'package.json');
+    try {
+        const raw = await external_fs_namespaceObject.promises.readFile(packageJsonPath, 'utf8');
+        const packageJson = JSON.parse(raw);
+        const currentVersion = packageJson?.devDependencies?.extension;
+        if ('string' != typeof currentVersion) return false;
+        const tag = getTagFallback(currentVersion);
+        if (!tag || currentVersion === tag) return false;
+        packageJson.devDependencies = {
+            ...packageJson.devDependencies || {},
+            extension: tag
+        };
+        await external_fs_namespaceObject.promises.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
+        return true;
+    } catch (error) {
+        console.error(cantInstallDependencies(projectName, error));
+        return false;
+    }
+}
+function shouldRetryWithTagFallback(output) {
+    const text = output.toLowerCase();
+    return text.includes('no matching version found for extension@') || text.includes('notarget') || text.includes('etarget');
+}
+async function install_dependencies_runInstall(command, args, cwd, stdio) {
+    return runInstall(command, args, {
+        cwd,
+        stdio
+    });
+}
+async function installDependencies(projectPath, projectName) {
+    const nodeModulesPath = external_path_namespaceObject.join(projectPath, 'node_modules');
+    const command = await getInstallCommand();
+    const dependenciesArgs = getInstallArgs();
+    const installMessage = installingDependencies();
+    const progressEnabled = shouldShowProgress();
+    const progress = startProgressBar(installMessage, {
+        enabled: progressEnabled,
+        persistLabel: true
+    });
+    if (!progressEnabled) console.log(installMessage);
+    try {
+        await external_fs_namespaceObject.promises.mkdir(nodeModulesPath, {
+            recursive: true
+        });
+        const stdio = 'development' === process.env.EXTENSION_ENV ? 'inherit' : 'pipe';
+        let firstRun;
+        try {
+            firstRun = await install_dependencies_runInstall(command, dependenciesArgs, projectPath, stdio);
+        } finally{
+            progress.stop();
+        }
+        if (0 !== firstRun.code) {
+            const output = `${firstRun.stdout}\n${firstRun.stderr}`;
+            const shouldRetry = shouldRetryWithTagFallback(output);
+            const didUpdate = shouldRetry ? await updateExtensionDependencyTag(projectPath, projectName) : false;
+            if (didUpdate) {
+                const retryProgress = startProgressBar(installMessage, {
+                    enabled: progressEnabled,
+                    persistLabel: true
+                });
+                let retryRun;
+                try {
+                    retryRun = await install_dependencies_runInstall(command, dependenciesArgs, projectPath, stdio);
+                } finally{
+                    retryProgress.stop();
+                }
+                if (0 === retryRun.code) return;
+            }
+            throw new Error(installingDependenciesFailed(command, dependenciesArgs, firstRun.code));
+        }
+    } catch (error) {
+        console.error(installingDependenciesProcessError(projectName, error));
+        console.error(cantInstallDependencies(projectName, error));
+        throw error;
+    }
+}
 const manifestSearchMaxDepth = 3;
 const ignoredManifestDirs = new Set([
     'node_modules',
@@ -703,7 +919,6 @@ async function writeGitignore(projectPath) {
         throw err;
     });
 }
-const external_cross_spawn_namespaceObject = require("cross-spawn");
 async function initializeGitRepository(projectPath, projectName) {
     const gitCommand = 'git';
     const gitArgs = [
@@ -741,7 +956,298 @@ async function setupBuiltInTests(projectPath, projectName) {
         throw error;
     }
 }
-async function extensionCreate(projectNameInput, { cliVersion, template = 'init', install: _install = false }) {
+const external_module_namespaceObject = require("module");
+const requireFromCreate = (0, external_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
+function resolveDevelopRoot(projectPath) {
+    const override = process.env.EXTENSION_CREATE_DEVELOP_ROOT;
+    if (override) return override;
+    try {
+        const localPkgPath = external_path_namespaceObject.join(projectPath, 'node_modules', 'extension-develop', 'package.json');
+        if (external_fs_namespaceObject.existsSync(localPkgPath)) return external_path_namespaceObject.dirname(localPkgPath);
+        const pkgPath = requireFromCreate.resolve('extension-develop/package.json', {
+            paths: [
+                projectPath,
+                process.cwd(),
+                __dirname
+            ]
+        });
+        return external_path_namespaceObject.dirname(pkgPath);
+    } catch  {
+        return null;
+    }
+}
+function resolveBuildDepsPath(developRoot) {
+    return external_path_namespaceObject.join(developRoot, 'webpack', 'webpack-lib', 'build-dependencies.json');
+}
+function loadBuildDependencies(developRoot) {
+    const metadataPath = resolveBuildDepsPath(developRoot);
+    if (!external_fs_namespaceObject.existsSync(metadataPath)) {
+        console.warn(`${installingBuildDependencies([])} (build-dependencies.json missing; skipping build deps install)`);
+        return {};
+    }
+    return JSON.parse(external_fs_namespaceObject.readFileSync(metadataPath, 'utf8'));
+}
+function readPackageJson(projectPath) {
+    try {
+        const raw = external_fs_namespaceObject.readFileSync(external_path_namespaceObject.join(projectPath, 'package.json'), 'utf8');
+        return JSON.parse(raw);
+    } catch  {
+        return {};
+    }
+}
+function hasDependency(pkg, name) {
+    return Boolean(pkg.dependencies?.[name] || pkg.devDependencies?.[name]);
+}
+function canResolve(dependency, paths) {
+    try {
+        requireFromCreate.resolve(dependency, {
+            paths
+        });
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function findConfigFile(projectPath, candidates) {
+    return candidates.some((file)=>external_fs_namespaceObject.existsSync(external_path_namespaceObject.join(projectPath, file)));
+}
+function detectOptionalDependencies(projectPath) {
+    const pkg = readPackageJson(projectPath);
+    const usesReact = hasDependency(pkg, 'react') || hasDependency(pkg, 'react-dom');
+    const usesPreact = hasDependency(pkg, 'preact');
+    const usesVue = hasDependency(pkg, 'vue');
+    const usesSvelte = hasDependency(pkg, 'svelte');
+    const hasTsConfig = external_fs_namespaceObject.existsSync(external_path_namespaceObject.join(projectPath, 'tsconfig.json'));
+    const usesTypeScript = hasDependency(pkg, "typescript") || hasTsConfig;
+    const usesSass = hasDependency(pkg, 'sass') || hasDependency(pkg, 'sass-loader');
+    const usesLess = hasDependency(pkg, 'less') || hasDependency(pkg, 'less-loader');
+    const postCssConfigFiles = [
+        '.postcssrc',
+        '.postcssrc.json',
+        '.postcssrc.yaml',
+        '.postcssrc.yml',
+        'postcss.config.mjs',
+        '.postcssrc.js',
+        '.postcssrc.cjs',
+        'postcss.config.js',
+        'postcss.config.cjs'
+    ];
+    const tailwindConfigFiles = [
+        'tailwind.config.mjs',
+        'tailwind.config.cjs',
+        'tailwind.config.js'
+    ];
+    const usesPostCss = hasDependency(pkg, 'postcss') || hasDependency(pkg, 'postcss-loader') || findConfigFile(projectPath, postCssConfigFiles) || hasDependency(pkg, 'tailwindcss') || hasDependency(pkg, '@tailwindcss/postcss') || findConfigFile(projectPath, tailwindConfigFiles);
+    const integrations = [];
+    const dependenciesByIntegration = {};
+    const deps = new Set();
+    const addIntegration = (name, depsForIntegration)=>{
+        if (!integrations.includes(name)) integrations.push(name);
+        if (!dependenciesByIntegration[name]) dependenciesByIntegration[name] = [];
+        for (const dep of depsForIntegration){
+            if (!dependenciesByIntegration[name].includes(dep)) dependenciesByIntegration[name].push(dep);
+            deps.add(dep);
+        }
+    };
+    if (usesTypeScript) addIntegration('TypeScript', [
+        "typescript"
+    ]);
+    if (usesReact) addIntegration('React', [
+        'react-refresh',
+        '@rspack/plugin-react-refresh'
+    ]);
+    if (usesPreact) addIntegration('Preact', [
+        '@prefresh/core',
+        '@prefresh/utils',
+        '@rspack/plugin-preact-refresh',
+        'preact'
+    ]);
+    if (usesVue) addIntegration('Vue', [
+        'vue-loader',
+        '@vue/compiler-sfc'
+    ]);
+    if (usesSvelte) addIntegration('Svelte', [
+        'svelte-loader',
+        "typescript"
+    ]);
+    if (usesSass) addIntegration('Sass', [
+        'sass-loader',
+        'postcss-loader',
+        'postcss-scss',
+        'postcss-preset-env'
+    ]);
+    if (usesLess) addIntegration('Less', [
+        'less',
+        'less-loader'
+    ]);
+    if (!usesPostCss || usesSass || usesLess) {
+        if (usesPostCss) addIntegration('PostCSS', []);
+    } else addIntegration('PostCSS', [
+        'postcss',
+        'postcss-loader'
+    ]);
+    return {
+        integrations,
+        dependencies: Array.from(deps),
+        dependenciesByIntegration
+    };
+}
+function buildOptionalInstallArgs(pm, dependencies, installDir) {
+    if ('yarn' === pm) return [
+        'add',
+        ...dependencies,
+        '--cwd',
+        installDir,
+        '--optional'
+    ];
+    if ('pnpm' === pm) return [
+        'add',
+        ...dependencies,
+        '--dir',
+        installDir,
+        '--save-optional'
+    ];
+    if ('bun' === pm) return [
+        'add',
+        ...dependencies,
+        '--cwd',
+        installDir,
+        '--optional'
+    ];
+    return [
+        'install',
+        ...dependencies,
+        '--prefix',
+        installDir,
+        '--save-optional'
+    ];
+}
+function buildBuildInstallArgs(pm, dependencies, dependencyMap) {
+    const depsWithVersions = dependencies.map((dep)=>`${dep}@${dependencyMap[dep]}`);
+    if ('yarn' === pm) return [
+        'add',
+        ...depsWithVersions
+    ];
+    if ('pnpm' === pm) return [
+        'add',
+        '--save',
+        ...depsWithVersions
+    ];
+    if ('bun' === pm) return [
+        'add',
+        ...depsWithVersions
+    ];
+    return [
+        'install',
+        '--save',
+        ...depsWithVersions
+    ];
+}
+function resolveMissingBuildDeps(developRoot) {
+    const dependencyMap = loadBuildDependencies(developRoot);
+    const candidates = Object.keys(dependencyMap);
+    const missing = candidates.filter((dep)=>!canResolve(dep, [
+            developRoot,
+            process.cwd()
+        ]));
+    return {
+        dependencies: missing,
+        dependencyMap
+    };
+}
+function resolveMissingOptionalDeps(developRoot, projectPath) {
+    const plan = detectOptionalDependencies(projectPath);
+    const dependenciesByIntegration = {};
+    const integrations = [];
+    const missing = new Set();
+    for (const integration of plan.integrations){
+        const depsForIntegration = plan.dependenciesByIntegration[integration] || [];
+        const missingForIntegration = depsForIntegration.filter((dep)=>!canResolve(dep, [
+                developRoot,
+                projectPath,
+                process.cwd()
+            ]));
+        if (0 !== missingForIntegration.length) {
+            integrations.push(integration);
+            dependenciesByIntegration[integration] = missingForIntegration;
+            missingForIntegration.forEach((dep)=>missing.add(dep));
+        }
+    }
+    return {
+        integrations,
+        dependencies: Array.from(missing),
+        dependenciesByIntegration
+    };
+}
+async function installBuildDependencies(developRoot, plan) {
+    if (0 === plan.dependencies.length) return;
+    const pm = detectPackageManagerFromEnv();
+    const installMessage = installingBuildDependencies(plan.dependencies);
+    const progressEnabled = shouldShowProgress();
+    const progress = startProgressBar(installMessage, {
+        enabled: progressEnabled,
+        persistLabel: true
+    });
+    if (!progressEnabled) console.log(installMessage);
+    try {
+        const args = buildBuildInstallArgs(pm, plan.dependencies, plan.dependencyMap);
+        const stdio = 'development' === process.env.EXTENSION_ENV ? 'inherit' : 'ignore';
+        const result = await runInstall(pm, args, {
+            cwd: developRoot,
+            stdio
+        });
+        if (0 !== result.code) throw new Error(installingDependenciesFailed(pm, args, result.code));
+    } finally{
+        progress.stop();
+    }
+}
+async function installOptionalDependencies(developRoot, projectPath, plan) {
+    if (0 === plan.dependencies.length) return;
+    const pm = detectPackageManagerFromEnv();
+    const stdio = 'development' === process.env.EXTENSION_ENV ? 'inherit' : 'ignore';
+    const progressEnabled = shouldShowProgress();
+    console.log(foundSpecializedDependencies(plan.dependencies.length));
+    for (const [index, integration] of plan.integrations.entries()){
+        const missingDeps = plan.dependenciesByIntegration[integration] || [];
+        const [baseMessage] = installingProjectIntegrations([
+            integration
+        ]);
+        const installMessage = baseMessage.replace('►►► ', `►►► [${index + 1}/${plan.integrations.length}] `);
+        const progress = startProgressBar(installMessage, {
+            enabled: progressEnabled,
+            persistLabel: true
+        });
+        if (!progressEnabled) console.log(installMessage);
+        try {
+            if (0 === missingDeps.length) continue;
+            for (const dep of missingDeps){
+                const args = buildOptionalInstallArgs(pm, [
+                    dep
+                ], developRoot);
+                const result = await runInstall(pm, args, {
+                    cwd: developRoot,
+                    stdio
+                });
+                if (0 !== result.code) throw new Error(installingDependenciesFailed(pm, args, result.code));
+            }
+        } finally{
+            progress.stop();
+        }
+    }
+}
+async function installInternalDependencies(projectPath) {
+    if ('test' === process.env.EXTENSION_ENV || 'true' === process.env.EXTENSION_SKIP_INTERNAL_INSTALL) return;
+    const developRoot = resolveDevelopRoot(projectPath);
+    if (!developRoot) return;
+    const buildPlan = resolveMissingBuildDeps(developRoot);
+    if (0 === buildPlan.dependencies.length) console.log(installingBuildDependencies(buildPlan.dependencies));
+    else await installBuildDependencies(developRoot, buildPlan);
+    const optionalPlan = resolveMissingOptionalDeps(developRoot, projectPath);
+    if (0 === optionalPlan.dependencies.length) {
+        if (optionalPlan.integrations.length > 0) installingProjectIntegrations(optionalPlan.integrations).forEach((message)=>console.log(message));
+    } else await installOptionalDependencies(developRoot, projectPath, optionalPlan);
+}
+async function extensionCreate(projectNameInput, { cliVersion, template = 'init', install = false }) {
     if (!projectNameInput) throw new Error(noProjectName());
     if (projectNameInput.startsWith('http')) throw new Error(noUrlAllowed());
     const projectPath = external_path_namespaceObject.isAbsolute(projectNameInput) ? projectNameInput : external_path_namespaceObject.join(process.cwd(), projectNameInput);
@@ -753,13 +1259,17 @@ async function extensionCreate(projectNameInput, { cliVersion, template = 'init'
             template,
             cliVersion
         });
+        if (install) {
+            await installDependencies(projectPath, projectName);
+            await installInternalDependencies(projectPath);
+        }
         await writeReadmeFile(projectPath, projectName);
         await writeManifestJson(projectPath, projectName);
         await initializeGitRepository(projectPath, projectName);
         await writeGitignore(projectPath);
         await setupBuiltInTests(projectPath, projectName);
         if (isTypeScriptTemplate(template)) await generateExtensionTypes(projectPath, projectName);
-        const successfulInstall = await successfullInstall(projectPath, projectName, false);
+        const successfulInstall = await successfullInstall(projectPath, projectName, Boolean(install));
         console.log(successfulInstall);
     } catch (error) {
         throw error;

package/dist/module.d.ts

@@ -3,4 +3,4 @@ export interface CreateOptions {
     install?: boolean;
     cliVersion?: string;
 }
-export declare function extensionCreate(projectNameInput: string | undefined, { cliVersion, template, install: _install }: CreateOptions): Promise<void>;
+export declare function extensionCreate(projectNameInput: string | undefined, { cliVersion, template, install }: CreateOptions): Promise<void>;

package/dist/steps/install-internal-deps.d.ts

@@ -0,0 +1,21 @@
+type OptionalDepsPlan = {
+    integrations: string[];
+    dependencies: string[];
+    dependenciesByIntegration: Record<string, string[]>;
+};
+type BuildDepsPlan = {
+    dependencies: string[];
+    dependencyMap: Record<string, string>;
+};
+declare function resolveDevelopRoot(projectPath: string): string | null;
+declare function detectOptionalDependencies(projectPath: string): OptionalDepsPlan;
+declare function resolveMissingBuildDeps(developRoot: string): BuildDepsPlan;
+declare function resolveMissingOptionalDeps(developRoot: string, projectPath: string): OptionalDepsPlan;
+export declare function installInternalDependencies(projectPath: string): Promise<void>;
+export declare const __testing__: {
+    resolveDevelopRoot: typeof resolveDevelopRoot;
+    resolveMissingBuildDeps: typeof resolveMissingBuildDeps;
+    resolveMissingOptionalDeps: typeof resolveMissingOptionalDeps;
+    detectOptionalDependencies: typeof detectOptionalDependencies;
+};
+export {};

package/package.json

@@ -23,7 +23,7 @@
     "dist"
   ],
   "name": "extension-create",
-  "version": "3.5.0-next.2",
+  "version": "3.5.0-next.20",
   "description": "The standalone extension creation engine for Extension.js",
   "author": {
     "name": "Cezar Augusto",
@@ -81,15 +81,15 @@
   "devDependencies": {
     "@changesets/cli": "^2.29.8",
     "@eslint/js": "^9.39.2",
-    "@rslib/core": "^0.19.2",
+    "@rslib/core": "^0.19.4",
     "@types/adm-zip": "^0.5.7",
     "@types/chrome": "^0.1.33",
     "@types/cross-spawn": "^6.0.6",
-    "@types/node": "^25.0.9",
+    "@types/node": "^25.2.0",
     "@types/webextension-polyfill": "0.12.4",
     "@vitest/coverage-v8": "^4.0.17",
     "eslint": "^9.39.2",
-    "globals": "^17.0.0",
+    "globals": "^17.3.0",
     "prettier": "^3.8.0",
     "tsconfig": "*",
     "typescript": "5.9.3",