extension-create 0.0.0-next-20250827130329

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Cezar Augusto <boss@cezaraugusto.net> (https://cezaraugusto.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,53 @@
+[npm-version-image]: https://img.shields.io/npm/v/extension-create.svg?color=0971fe
+[npm-version-url]: https://www.npmjs.com/package/extension-create
+[downloads-image]: https://img.shields.io/npm/dm/extension-create.svg?color=2ecc40
+[downloads-url]: https://npmjs.org/package/extension-create
+[empowering-image]: https://img.shields.io/badge/Empowering-Extension.js-0971fe
+[empowering-url]: https://extension.js.org
+
+[![Empowering][empowering-image]][empowering-url] [![Version][npm-version-image]][npm-version-url] [![Downloads][downloads-image]][downloads-url]
+
+# extension-create
+
+> Scaffold a new [Extension.js](https://extension.js.org) project from a template.
+
+This package implements the logic Extension.js uses to scaffold a new extension project from a selected template.
+It performs, in order:
+
+- Create or reuse the target directory (and fail on conflicting files)
+- Import the selected template (local in dev, remote via Git in prod)
+- Write `package.json` metadata and add Extension.js scripts
+- Write `manifest.json` metadata
+- Initialize a Git repository
+- Write a `.gitignore`
+- Remove template-only test files
+- If the template is TypeScript-based, generate `extension-env.d.ts`
+
+## Installation
+
+```
+pnpm add extension-create
+```
+
+## Usage
+
+```js
+import {extensionCreate} from 'extension-create'
+
+async function createNewExtension () {
+  await extensionCreate(
+    projectName: /* string (required) */,
+    {
+      template: 'init', // or any template name (see /examples)
+      install: false,   // optionally run the package manager install step
+      cliVersion: '2.x' // used to pin the CLI when not in dev mode
+    }
+  )
+}
+
+createNewExtension()
+```
+
+## License
+
+MIT (c) Cezar Augusto.

package/dist/lib/messages.d.ts

@@ -0,0 +1,31 @@
+export declare function destinationNotWriteable(workingDir: string): string;
+export declare function directoryHasConflicts(projectPath: string, conflictingFiles: string[]): Promise<string>;
+export declare function noProjectName(): string;
+export declare function noUrlAllowed(): string;
+export declare function successfullInstall(projectPath: string, projectName: string): Promise<string>;
+export declare function startingNewExtension(projectName: string): string;
+export declare function checkingIfPathIsWriteable(): string;
+export declare function scanningPossiblyConflictingFiles(): string;
+export declare function createDirectoryError(projectName: string, error: any): string;
+export declare function writingTypeDefinitions(projectName: string): string;
+export declare function writingTypeDefinitionsError(error: any): string;
+export declare function installingFromTemplate(projectName: string, templateName: string): string;
+export declare function installingFromTemplateError(projectName: string, template: string, error: any): string;
+export declare function initializingGitForRepository(projectName: string): string;
+export declare function initializingGitForRepositoryFailed(gitCommand: string, gitArgs: string[], code: number | null): string;
+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 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;
+export declare function writingPackageJsonMetadata(): string;
+export declare function writingPackageJsonMetadataError(projectName: string, error: any): string;
+export declare function writingManifestJsonMetadata(): string;
+export declare function writingManifestJsonMetadataError(projectName: string, error: any): string;
+export declare function writingReadmeMetaData(): string;
+export declare function writingGitIgnore(): string;
+export declare function writingReadmeMetaDataEError(projectName: string, error: any): string;
+export declare function folderExists(projectName: string): string;
+export declare function writingDirectoryError(error: any): string;
+export declare function cantSetupBuiltInTests(projectName: string, error: any): string;

package/dist/lib/types.d.ts

@@ -0,0 +1,26 @@
+declare namespace NodeJS {
+    interface ProcessEnv {
+        EXTENSION_BROWSER: 'chrome' | 'edge' | 'firefox' | 'chromium-based' | 'gecko-based';
+        EXTENSION_MODE: 'development' | 'production';
+        EXTENSION_PUBLIC_BROWSER: 'chrome' | 'edge' | 'firefox' | 'chromium-based' | 'gecko-based';
+        EXTENSION_PUBLIC_MODE: 'development' | 'production';
+        EXTENSION_PUBLIC_DESCRIPTION_TEXT: string;
+        EXTENSION_PUBLIC_OPENAI_API_KEY: string;
+        EXTENSION_ENV: 'development' | 'production';
+    }
+}
+interface ImportMetaEnv {
+    EXTENSION_BROWSER: NodeJS.ProcessEnv['EXTENSION_BROWSER'];
+    EXTENSION_MODE: NodeJS.ProcessEnv['EXTENSION_MODE'];
+    EXTENSION_PUBLIC_BROWSER: NodeJS.ProcessEnv['EXTENSION_BROWSER'];
+    EXTENSION_PUBLIC_MODE: NodeJS.ProcessEnv['EXTENSION_MODE'];
+    [key: string]: string | undefined;
+}
+interface ImportMeta {
+    readonly env: ImportMetaEnv;
+    readonly webpackHot?: {
+        accept: (module?: string | string[], callback?: () => void) => void;
+        dispose: (callback: () => void) => void;
+    };
+    url: string;
+}

package/dist/lib/utils.d.ts

@@ -0,0 +1,8 @@
+export declare function copyDirectory(source: string, destination: string): Promise<void[]>;
+export declare function copyDirectoryWithSymlinks(source: string, destination: string): Promise<void>;
+export declare function moveDirectoryContents(source: string, destination: string): Promise<void>;
+export declare function getInstallCommand(): Promise<string>;
+export declare function getTemplatePath(workingDir: string): string;
+export declare function isDirectoryWriteable(directory: string, projectName: string): Promise<boolean>;
+export declare function isExternalTemplate(_templateName: string): boolean;
+export declare function isTypeScriptTemplate(templateName: string): boolean;

package/dist/module.d.ts

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

package/dist/module.js

@@ -0,0 +1,677 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return 'undefined' == typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    extensionCreate: ()=>extensionCreate
+});
+const external_path_namespaceObject = require("path");
+const external_fs_namespaceObject = require("fs");
+const external_pintor_namespaceObject = require("pintor");
+var external_pintor_default = /*#__PURE__*/ __webpack_require__.n(external_pintor_namespaceObject);
+const external_package_manager_detector_namespaceObject = require("package-manager-detector");
+function destinationNotWriteable(workingDir) {
+    const workingDirFolder = external_path_namespaceObject.basename(workingDir);
+    return `${external_pintor_default().red('ERROR')} Failed to write in the destination directory.\n${external_pintor_default().red('Path is not writable. Ensure you have write permissions for this folder.')}\n${external_pintor_default().red('NOT WRITEABLE')} ${external_pintor_default().underline(workingDirFolder)}`;
+}
+async function directoryHasConflicts(projectPath, conflictingFiles) {
+    const projectName = external_path_namespaceObject.basename(projectPath);
+    let message = `Conflict! Path to ${external_pintor_default().yellow(projectName)} includes conflicting files.\n`;
+    for (const file of conflictingFiles){
+        const stats = await external_fs_namespaceObject.promises.lstat(external_path_namespaceObject.join(projectPath, file));
+        message += stats.isDirectory() ? `${external_pintor_default().gray('-')} ${external_pintor_default().yellow(file)}\n` : `${external_pintor_default().gray('-')} ${external_pintor_default().yellow(file)}\n`;
+    }
+    message += `${external_pintor_default().red('You need to either rename/remove the files listed above, or choose a new directory name for your extension.')}\nPath to conflicting directory: ${external_pintor_default().underline(projectPath)}`;
+    return message;
+}
+function noProjectName() {
+    return `${external_pintor_default().red('ERROR')} You need to provide an extension name to create one. See ${external_pintor_default().blue('--help')} for command info.`;
+}
+function noUrlAllowed() {
+    return `${external_pintor_default().red('ERROR')} URLs are not allowed as a project path. Either write a name or a path to a local folder.`;
+}
+async function successfullInstall(projectPath, projectName) {
+    const relativePath = external_path_namespaceObject.relative(process.cwd(), projectPath);
+    const pm = await (0, external_package_manager_detector_namespaceObject.detect)();
+    let command = 'npm run';
+    let installCmd = 'npm install';
+    switch(null == pm ? void 0 : pm.name){
+        case 'yarn':
+            command = 'yarn dev';
+            installCmd = 'yarn';
+            break;
+        case 'pnpm':
+            command = 'pnpm dev';
+            installCmd = 'pnpm install';
+            break;
+        default:
+            command = 'npm run dev';
+            installCmd = 'npm install';
+    }
+    if (process.env.npm_config_user_agent) {
+        if (process.env.npm_config_user_agent.includes('pnpm')) {
+            command = 'pnpm dev';
+            installCmd = 'pnpm install';
+        }
+    }
+    return `\u{1F9E9} - ${external_pintor_default().green('Success!')} Extension ${external_pintor_default().yellow(projectName)} created.\nNow ${external_pintor_default().blue('cd')} ${external_pintor_default().underline(relativePath)}\n${external_pintor_default().blue(installCmd)} to install dependencies\n${external_pintor_default().blue(command)} to open a new browser instance\nwith your extension installed, loaded, and enabled for development.\n${external_pintor_default().green('You are ready')}. Time to hack on your extension!`;
+}
+function startingNewExtension(projectName) {
+    return `\u{1F423} - Starting a new browser extension named ${external_pintor_default().yellow(projectName)}...`;
+}
+function checkingIfPathIsWriteable() {
+    return `\u{1F91E} - Checking if destination path is writeable...`;
+}
+function scanningPossiblyConflictingFiles() {
+    return "\uD83D\uDD0E - Scanning for potential conflicting files...";
+}
+function createDirectoryError(projectName, error) {
+    return `${external_pintor_default().red('ERROR')} Can't create directory ${external_pintor_default().yellow(projectName)}.\n${external_pintor_default().red(String(error))}`;
+}
+function writingTypeDefinitions(projectName) {
+    return `\u{1F537} - Writing type definitions for ${external_pintor_default().yellow(projectName)}...`;
+}
+function writingTypeDefinitionsError(error) {
+    return `${external_pintor_default().red('ERROR')} Failed to write the extension type definition.\n${external_pintor_default().red(String(error))}`;
+}
+function installingFromTemplate(projectName, templateName) {
+    if ('init' === templateName) return `\u{1F9F0} - Installing ${external_pintor_default().yellow(projectName)}...`;
+    return `\u{1F9F0} - Installing ${external_pintor_default().yellow(projectName)} from template ${external_pintor_default().yellow(templateName)}...`;
+}
+function installingFromTemplateError(projectName, template, error) {
+    return `${external_pintor_default().red('ERROR')} Can't find template ${external_pintor_default().yellow(template)} for ${external_pintor_default().yellow(projectName)}.\n${external_pintor_default().red(String(error))}`;
+}
+function initializingGitForRepository(projectName) {
+    return `\u{1F332} - Initializing git repository for ${external_pintor_default().yellow(projectName)}...`;
+}
+function initializingGitForRepositoryFailed(gitCommand, gitArgs, code) {
+    return `${external_pintor_default().red('ERROR')} Command ${external_pintor_default().gray(gitCommand)} ${external_pintor_default().gray(gitArgs.join(' '))} failed.\n${external_pintor_default().red(`exit code ${external_pintor_default().gray(String(code))}`)}`;
+}
+function initializingGitForRepositoryProcessError(projectName, error) {
+    return `${external_pintor_default().red('ERROR')} Child process error: Can't initialize ${external_pintor_default().gray('git')} for ${external_pintor_default().yellow(projectName)}.\n${external_pintor_default().red(String((null == error ? void 0 : error.message) || error))}`;
+}
+function initializingGitForRepositoryError(projectName, error) {
+    return `${external_pintor_default().red('ERROR')} Can't initialize ${external_pintor_default().gray('git')} for ${external_pintor_default().yellow(projectName)}.\n${external_pintor_default().red(String((null == error ? void 0 : error.message) || error))}`;
+}
+function installingDependencies() {
+    return "\uD83D\uDEE0  - Installing dependencies... (takes a moment)";
+}
+function installingDependenciesFailed(gitCommand, gitArgs, code) {
+    return `${external_pintor_default().red('ERROR')} Command ${external_pintor_default().gray(gitCommand)} ${external_pintor_default().gray(gitArgs.join(' '))} failed.\n${external_pintor_default().red(`exit code ${external_pintor_default().gray(String(code))}`)}`;
+}
+function installingDependenciesProcessError(projectName, error) {
+    return `${external_pintor_default().red('ERROR')} Child process error: Can't install dependencies for ${external_pintor_default().yellow(projectName)}.\n${external_pintor_default().red(String(error))}`;
+}
+function cantInstallDependencies(projectName, error) {
+    return `${external_pintor_default().red('ERROR')} Can't install dependencies for ${external_pintor_default().yellow(projectName)}.\n${external_pintor_default().red(String((null == error ? void 0 : error.message) || error))}`;
+}
+function writingPackageJsonMetadata() {
+    return `\u{1F4DD} - Writing ${external_pintor_default().yellow('package.json')} metadata...`;
+}
+function writingPackageJsonMetadataError(projectName, error) {
+    return `${external_pintor_default().red('ERROR')} Can't write ${external_pintor_default().yellow('package.json')} for ${external_pintor_default().yellow(projectName)}.\n${external_pintor_default().red(String(error))}`;
+}
+function writingManifestJsonMetadata() {
+    return `\u{1F4DC} - Writing ${external_pintor_default().yellow('manifest.json')} metadata...`;
+}
+function writingManifestJsonMetadataError(projectName, error) {
+    return `${external_pintor_default().red('ERROR')} Can't write ${external_pintor_default().yellow('manifest.json')} for ${external_pintor_default().yellow(projectName)}.\n${external_pintor_default().red(String(error))}`;
+}
+function writingReadmeMetaData() {
+    return `\u{1F4C4} - Writing ${external_pintor_default().yellow('README.md')} metadata...`;
+}
+function writingGitIgnore() {
+    return `\u{1F648} - Writing ${external_pintor_default().yellow('.gitignore')} lines...`;
+}
+function writingReadmeMetaDataEError(projectName, error) {
+    return `${external_pintor_default().red('ERROR')} Can't write the ${external_pintor_default().yellow('README.md')} file for ${external_pintor_default().yellow(projectName)}.\n${external_pintor_default().red(String(error))}`;
+}
+function folderExists(projectName) {
+    return `\u{1F91D} - Ensuring ${external_pintor_default().yellow(projectName)} folder exists...`;
+}
+function writingDirectoryError(error) {
+    return `${external_pintor_default().red('ERROR')} Error while checking directory writability.\n${external_pintor_default().red(String(error))}`;
+}
+function cantSetupBuiltInTests(projectName, error) {
+    return `${external_pintor_default().red('ERROR')} Can't setup built-in tests for ${external_pintor_default().yellow(projectName)}.\n${external_pintor_default().red(String(error))}`;
+}
+const promises_namespaceObject = require("fs/promises");
+const external_url_namespaceObject = require("url");
+const utils_filename = (0, external_url_namespaceObject.fileURLToPath)(__rslib_import_meta_url__);
+const utils_dirname = external_path_namespaceObject.dirname(utils_filename);
+async function copyDirectoryWithSymlinks(source, destination) {
+    const entries = await promises_namespaceObject.readdir(source, {
+        withFileTypes: true
+    });
+    await promises_namespaceObject.mkdir(destination, {
+        recursive: true
+    });
+    for (const entry of entries){
+        const sourcePath = external_path_namespaceObject.join(source, entry.name);
+        const destPath = external_path_namespaceObject.join(destination, entry.name);
+        if (entry.isDirectory()) await copyDirectoryWithSymlinks(sourcePath, destPath);
+        else if (entry.isSymbolicLink()) {
+            const target = await promises_namespaceObject.readlink(sourcePath);
+            await promises_namespaceObject.symlink(target, destPath);
+        } else await promises_namespaceObject.copyFile(sourcePath, destPath);
+    }
+}
+async function moveDirectoryContents(source, destination) {
+    await promises_namespaceObject.mkdir(destination, {
+        recursive: true
+    });
+    const entries = await promises_namespaceObject.readdir(source, {
+        withFileTypes: true
+    });
+    for (const entry of entries){
+        const sourcePath = external_path_namespaceObject.join(source, entry.name);
+        const destPath = external_path_namespaceObject.join(destination, entry.name);
+        if (entry.isDirectory()) await moveDirectoryContents(sourcePath, destPath);
+        else if (entry.isSymbolicLink()) {
+            const target = await promises_namespaceObject.readlink(sourcePath);
+            await promises_namespaceObject.symlink(target, destPath);
+        } else await promises_namespaceObject.rename(sourcePath, destPath);
+    }
+    await promises_namespaceObject.rm(source, {
+        recursive: true,
+        force: true
+    });
+}
+async function getInstallCommand() {
+    const pm = await (0, external_package_manager_detector_namespaceObject.detect)();
+    let command = 'npm';
+    if (process.env.npm_config_user_agent) {
+        if (process.env.npm_config_user_agent.includes('pnpm')) return 'pnpm';
+    }
+    switch(null == pm ? void 0 : pm.name){
+        case 'yarn':
+            command = 'yarn';
+            break;
+        case 'pnpm':
+            command = 'pnpm';
+            break;
+        default:
+            command = 'npm';
+    }
+    return command;
+}
+function getTemplatePath(workingDir) {
+    const templatesDir = external_path_namespaceObject.resolve(utils_dirname, '..', 'template');
+    return external_path_namespaceObject.resolve(workingDir, templatesDir);
+}
+async function isDirectoryWriteable(directory, projectName) {
+    try {
+        console.log(folderExists(projectName));
+        await promises_namespaceObject.mkdir(directory, {
+            recursive: true
+        });
+        return true;
+    } catch (err) {
+        console.log(writingDirectoryError(err));
+        return false;
+    }
+}
+function isExternalTemplate(_templateName) {
+    return true;
+}
+function isTypeScriptTemplate(templateName) {
+    return templateName.includes("typescript") || templateName.includes('react') || templateName.includes('preact') || templateName.includes('svelte') || templateName.includes('solid');
+}
+const allowlist = [
+    'LICENSE',
+    'node_modules'
+];
+async function createDirectory(projectPath, projectName) {
+    console.log(startingNewExtension(projectName));
+    try {
+        const isCurrentDirWriteable = await isDirectoryWriteable(projectPath, projectName);
+        console.log(checkingIfPathIsWriteable());
+        if (!isCurrentDirWriteable) {
+            console.error(destinationNotWriteable(projectPath));
+            throw new Error(destinationNotWriteable(projectPath));
+        }
+        const currentDir = await promises_namespaceObject.readdir(projectPath);
+        console.log(scanningPossiblyConflictingFiles());
+        const conflictingFiles = await Promise.all(currentDir.filter((file)=>!file.startsWith('.')).filter((file)=>!file.endsWith('.log')).filter((file)=>!allowlist.includes(file)).map(async (file)=>{
+            const stats = await promises_namespaceObject.lstat(external_path_namespaceObject.join(projectPath, file));
+            return stats.isDirectory() ? `${file}/` : `${file}`;
+        }));
+        if (conflictingFiles.length > 0) {
+            const conflictMessage = await directoryHasConflicts(projectPath, conflictingFiles);
+            throw new Error(conflictMessage);
+        }
+    } catch (error) {
+        console.error(createDirectoryError(projectName, error));
+        throw error;
+    }
+}
+const external_os_namespaceObject = require("os");
+const external_axios_namespaceObject = require("axios");
+var external_axios_default = /*#__PURE__*/ __webpack_require__.n(external_axios_namespaceObject);
+const external_adm_zip_namespaceObject = require("adm-zip");
+var external_adm_zip_default = /*#__PURE__*/ __webpack_require__.n(external_adm_zip_namespaceObject);
+const external_go_git_it_namespaceObject = require("go-git-it");
+var external_go_git_it_default = /*#__PURE__*/ __webpack_require__.n(external_go_git_it_namespaceObject);
+const import_external_template_filename = (0, external_url_namespaceObject.fileURLToPath)(__rslib_import_meta_url__);
+const import_external_template_dirname = external_path_namespaceObject.dirname(import_external_template_filename);
+async function importExternalTemplate(projectPath, projectName, template) {
+    external_path_namespaceObject.dirname(projectPath);
+    const templateName = external_path_namespaceObject.basename(template);
+    const examplesUrl = 'https://github.com/extension-js/examples/tree/main/examples';
+    const templateUrl = `${examplesUrl}/${template}`;
+    try {
+        await promises_namespaceObject.mkdir(projectPath, {
+            recursive: true
+        });
+        if ('development' === process.env.EXTENSION_ENV) {
+            console.log(installingFromTemplate(projectName, template));
+            const localTemplatePath = external_path_namespaceObject.join(import_external_template_dirname, '..', '..', '..', 'examples', templateName);
+            await copyDirectoryWithSymlinks(localTemplatePath, projectPath);
+        } else {
+            const tempRoot = await promises_namespaceObject.mkdtemp(external_path_namespaceObject.join(external_os_namespaceObject.tmpdir(), 'extension-js-create-'));
+            const tempPath = external_path_namespaceObject.join(tempRoot, projectName + '-temp');
+            await promises_namespaceObject.mkdir(tempPath, {
+                recursive: true
+            });
+            const isHttp = /^https?:\/\//i.test(template);
+            const isGithub = /^https?:\/\/github.com\//i.test(template);
+            if (isGithub) {
+                await external_go_git_it_default()(template, tempPath, installingFromTemplate(projectName, templateName));
+                const candidates = await promises_namespaceObject.readdir(tempPath, {
+                    withFileTypes: true
+                });
+                const preferred = candidates.find((d)=>d.isDirectory() && d.name === templateName);
+                const srcPath = preferred ? external_path_namespaceObject.join(tempPath, templateName) : tempPath;
+                await moveDirectoryContents(srcPath, projectPath);
+            } else if (isHttp) {
+                const { data, headers } = await external_axios_default().get(template, {
+                    responseType: 'arraybuffer',
+                    maxRedirects: 5
+                });
+                const contentType = String((null == headers ? void 0 : headers['content-type']) || '');
+                const looksZip = /zip|octet-stream/i.test(contentType) || template.toLowerCase().endsWith('.zip');
+                if (!looksZip) throw new Error(`Remote template does not appear to be a ZIP archive: ${template}`);
+                const zip = new (external_adm_zip_default())(Buffer.from(data));
+                zip.extractAllTo(tempPath, true);
+                await moveDirectoryContents(tempPath, projectPath);
+            } else {
+                await external_go_git_it_default()(templateUrl, tempPath, installingFromTemplate(projectName, templateName));
+                const srcPath = external_path_namespaceObject.join(tempPath, templateName);
+                await moveDirectoryContents(srcPath, projectPath);
+            }
+            await promises_namespaceObject.rm(tempRoot, {
+                recursive: true,
+                force: true
+            });
+        }
+    } catch (error) {
+        console.error(installingFromTemplateError(projectName, templateName, error));
+        throw error;
+    }
+}
+const extensionJsPackageJsonScripts = {
+    dev: 'development' === process.env.EXTENSION_ENV ? 'node node_modules/extension dev' : 'extension dev',
+    start: 'development' === process.env.EXTENSION_ENV ? 'node node_modules/extension start' : 'extension start',
+    build: 'development' === process.env.EXTENSION_ENV ? 'node node_modules/extension build' : 'extension build'
+};
+async function overridePackageJson(projectPath, projectName, { template, cliVersion }) {
+    const templatePath = getTemplatePath(process.cwd());
+    const candidatePath = isExternalTemplate(template) ? external_path_namespaceObject.join(projectPath, 'package.json') : external_path_namespaceObject.join(templatePath, 'package.json');
+    let packageJson = {};
+    try {
+        const packageJsonContent = await promises_namespaceObject.readFile(candidatePath);
+        packageJson = JSON.parse(packageJsonContent.toString());
+    } catch  {
+        packageJson = {
+            name: external_path_namespaceObject.basename(projectPath),
+            private: true,
+            scripts: {},
+            dependencies: {},
+            devDependencies: {}
+        };
+    }
+    packageJson.scripts = packageJson.scripts || {};
+    packageJson.dependencies = packageJson.dependencies || {};
+    packageJson.devDependencies = {
+        ...packageJson.devDependencies || {},
+        extension: 'development' === process.env.EXTENSION_ENV ? '*' : `^${cliVersion}`
+    };
+    const packageMetadata = {
+        ...packageJson,
+        name: external_path_namespaceObject.basename(projectPath),
+        private: true,
+        scripts: {
+            ...packageJson.scripts,
+            ...extensionJsPackageJsonScripts
+        },
+        dependencies: packageJson.dependencies,
+        devDependencies: packageJson.devDependencies,
+        author: {
+            name: 'Your Name',
+            email: 'your@email.com',
+            url: 'https://yourwebsite.com'
+        }
+    };
+    try {
+        console.log(writingPackageJsonMetadata());
+        await promises_namespaceObject.writeFile(external_path_namespaceObject.join(projectPath, 'package.json'), JSON.stringify(packageMetadata, null, 2));
+    } catch (error) {
+        console.error(writingPackageJsonMetadataError(projectName, error));
+        throw error;
+    }
+}
+const external_cross_spawn_namespaceObject = require("cross-spawn");
+function getInstallArgs() {
+    return [
+        'install',
+        '--silent'
+    ];
+}
+async function installDependencies(projectPath, projectName) {
+    const nodeModulesPath = external_path_namespaceObject.join(projectPath, 'node_modules');
+    const command = await getInstallCommand();
+    const dependenciesArgs = getInstallArgs();
+    console.log(installingDependencies());
+    try {
+        await external_fs_namespaceObject.promises.mkdir(nodeModulesPath, {
+            recursive: true
+        });
+        const stdio = 'development' === process.env.EXTENSION_ENV ? 'inherit' : 'ignore';
+        const child = (0, external_cross_spawn_namespaceObject.spawn)(command, dependenciesArgs, {
+            stdio,
+            cwd: projectPath
+        });
+        await new Promise((resolve, reject)=>{
+            child.on('close', (code)=>{
+                if (0 !== code) reject(new Error(installingDependenciesFailed(command, dependenciesArgs, code)));
+                else resolve();
+            });
+            child.on('error', (error)=>{
+                console.error(installingDependenciesProcessError(projectName, error));
+                reject(error);
+            });
+        });
+    } catch (error) {
+        console.error(cantInstallDependencies(projectName, error));
+        throw error;
+    }
+}
+async function writeReadmeFile(projectPath, projectName) {
+    try {
+        await promises_namespaceObject.access(external_path_namespaceObject.join(projectPath, 'README.md'));
+        return;
+    } catch  {}
+    const initTemplateReadme = `
+<a href="https://extension.js.org" target="_blank"><img src="https://img.shields.io/badge/Powered%20by%20%7C%20Extension.js-0971fe" alt="Powered by Extension.js" align="right" /></a>
+
+# [projectName]
+
+> [templateDescription]
+
+What this example does in the scope of a browser extension. The description should 
+describe for an audience of developers looking to use the example. Avoid jargon and 
+use simple language.
+
+## Installation
+
+\`\`\`bash
+[runCommand] create <project-name> --template init
+cd <project-name>
+npm install
+\`\`\`
+
+## Commands
+
+### dev
+
+Run the extension in development mode.
+
+\`\`\`bash
+[runCommand] dev
+\`\`\`
+
+### build
+
+Build the extension for production.
+
+\`\`\`bash
+[runCommand] build
+\`\`\`
+
+### Preview
+
+Preview the extension in the browser.
+
+\`\`\`bash
+[runCommand] preview
+\`\`\`
+
+## Learn more
+
+Learn more about this and other examples at @https://extension.js.org/
+  `;
+    const installCommand = await getInstallCommand();
+    const manifestJsonPath = external_path_namespaceObject.join(projectPath, 'manifest.json');
+    const manifestJson = JSON.parse(await promises_namespaceObject.readFile(manifestJsonPath, 'utf-8'));
+    const readmeFileEdited = initTemplateReadme.replaceAll('[projectName]', projectName).replaceAll("[templateDescription]", manifestJson.description).replaceAll('[runCommand]', installCommand);
+    try {
+        console.log(writingReadmeMetaData());
+        await promises_namespaceObject.mkdir(projectPath, {
+            recursive: true
+        });
+        await promises_namespaceObject.writeFile(external_path_namespaceObject.join(projectPath, 'README.md'), readmeFileEdited);
+    } catch (error) {
+        console.error(writingReadmeMetaDataEError(projectName, error));
+        throw error;
+    }
+}
+async function writeManifestJson(projectPath, projectName) {
+    const manifestJsonPath = external_path_namespaceObject.join(projectPath, 'manifest.json');
+    const manifestJsonContent = await promises_namespaceObject.readFile(manifestJsonPath);
+    const manifestJson = JSON.parse(manifestJsonContent.toString());
+    const manifestMetadata = {
+        ...manifestJson,
+        name: external_path_namespaceObject.basename(projectPath),
+        author: 'Your Name'
+    };
+    try {
+        console.log(writingManifestJsonMetadata());
+        await promises_namespaceObject.writeFile(external_path_namespaceObject.join(projectPath, 'manifest.json'), JSON.stringify(manifestMetadata, null, 2));
+    } catch (error) {
+        console.error(writingManifestJsonMetadataError(projectName, error));
+        throw error;
+    }
+}
+async function generateExtensionTypes(projectPath, projectName) {
+    const extensionEnvFile = external_path_namespaceObject.join(projectPath, 'extension-env.d.ts');
+    const typePath = 'extension';
+    const fileContent = `\
+// Required Extension.js types for TypeScript projects.
+// This file is auto-generated and should not be excluded.
+// If you need additional types, consider creating a new *.d.ts file and
+// referencing it in the "include" array of your tsconfig.json file.
+// See https://www.typescriptlang.org/tsconfig#include for more information.
+/// <reference types="${typePath}/types" />
+
+// Polyfill types for browser.* APIs
+/// <reference types="${typePath}/types/polyfill" />
+`;
+    try {
+        await promises_namespaceObject.mkdir(projectPath, {
+            recursive: true
+        });
+        console.log(writingTypeDefinitions(projectName));
+        await promises_namespaceObject.writeFile(extensionEnvFile, fileContent);
+    } catch (error) {
+        console.error(writingTypeDefinitionsError(error));
+        throw error;
+    }
+}
+const globalDependencies = [
+    '',
+    '# dependencies',
+    'node_modules'
+];
+const globalTesting = [
+    '',
+    '# testing',
+    'coverage'
+];
+const globalProduction = [
+    '',
+    '# production',
+    'dist'
+];
+const globalMisc = [
+    '',
+    '# misc',
+    '.DS_Store'
+];
+const envFiles = [
+    '',
+    '# local env files',
+    '.env.local',
+    '.env.development.local',
+    '.env.test.local',
+    '.env.production.local'
+];
+const debugFiles = [
+    '',
+    '# debug files',
+    'npm-debug.log*',
+    'yarn-debug.log*',
+    'yarn-error.log*'
+];
+const globalLines = [
+    '# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.',
+    ...globalDependencies,
+    ...globalTesting,
+    ...globalProduction,
+    ...globalMisc,
+    ...envFiles,
+    ...debugFiles
+];
+async function writeGitignore(projectPath) {
+    const gitIgnorePath = external_path_namespaceObject.join(projectPath, '.gitignore');
+    const fileHandle = await promises_namespaceObject.open(gitIgnorePath, 'a+').catch((err)=>{
+        console.error(err);
+        throw err;
+    });
+    const paths = new Set();
+    for await (let line of fileHandle.readLines({
+        autoClose: false
+    })){
+        line = line.trim();
+        if (0 !== line.length) paths.add(line);
+    }
+    const linesToAdd = globalLines.filter((line)=>!paths.has(line));
+    while('' === linesToAdd[linesToAdd.length - 1])linesToAdd.pop();
+    console.log(writingGitIgnore());
+    await fileHandle.appendFile(linesToAdd.join('\n')).catch((err)=>{
+        console.error(err);
+        throw err;
+    });
+}
+async function initializeGitRepository(projectPath, projectName) {
+    const gitCommand = 'git';
+    const gitArgs = [
+        'init',
+        '--quiet'
+    ];
+    console.log(initializingGitForRepository(projectName));
+    try {
+        const stdio = 'development' === process.env.EXTENSION_ENV ? 'inherit' : 'ignore';
+        const child = (0, external_cross_spawn_namespaceObject.spawn)(gitCommand, gitArgs, {
+            stdio,
+            cwd: projectPath
+        });
+        await new Promise((resolve, reject)=>{
+            child.on('close', (code)=>{
+                if (0 !== code) reject(new Error(initializingGitForRepositoryFailed(gitCommand, gitArgs, code)));
+                else resolve();
+            });
+            child.on('error', (error)=>{
+                console.error(initializingGitForRepositoryProcessError(projectName, error));
+                reject(error);
+            });
+        });
+    } catch (error) {
+        console.error(initializingGitForRepositoryError(projectName, error));
+        throw error;
+    }
+}
+async function setupBuiltInTests(projectPath, projectName) {
+    try {
+        const testSpecPath = external_path_namespaceObject.join(projectPath, 'tests', 'templates.spec.ts');
+        if (external_fs_namespaceObject.existsSync(testSpecPath)) external_fs_namespaceObject.unlinkSync(testSpecPath);
+    } catch (error) {
+        console.error(cantSetupBuiltInTests(projectName, error));
+        throw error;
+    }
+}
+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);
+    const projectName = external_path_namespaceObject.basename(projectPath);
+    try {
+        await createDirectory(projectPath, projectName);
+        await importExternalTemplate(projectPath, projectName, template);
+        await overridePackageJson(projectPath, projectName, {
+            template,
+            cliVersion
+        });
+        if (install) await installDependencies(projectPath, projectName);
+        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);
+        console.log(successfulInstall);
+    } catch (error) {
+        console.error(error);
+        throw error;
+    }
+}
+exports.extensionCreate = __webpack_exports__.extensionCreate;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "extensionCreate"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/rslib.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@rslib/core").RslibConfig;
+export default _default;

package/dist/steps/create-directory.d.ts

@@ -0,0 +1 @@
+export declare function createDirectory(projectPath: string, projectName: string): Promise<void>;

package/dist/steps/generate-extension-types.d.ts

@@ -0,0 +1 @@
+export declare function generateExtensionTypes(projectPath: string, projectName: string): Promise<void>;

package/dist/steps/import-external-template.d.ts

@@ -0,0 +1 @@
+export declare function importExternalTemplate(projectPath: string, projectName: string, template: string): Promise<void>;

package/dist/steps/import-local-template.d.ts

@@ -0,0 +1 @@
+export declare function importLocalTemplate(projectPath: string, projectName: string, template: string): Promise<void>;

package/dist/steps/initialize-git-repository.d.ts

@@ -0,0 +1 @@
+export declare function initializeGitRepository(projectPath: string, projectName: string): Promise<void>;

package/dist/steps/install-dependencies.d.ts

@@ -0,0 +1 @@
+export declare function installDependencies(projectPath: string, projectName: string): Promise<void>;

package/dist/steps/setup-built-in-tests.d.ts

@@ -0,0 +1 @@
+export declare function setupBuiltInTests(projectPath: string, projectName: string): Promise<void>;

package/dist/steps/write-gitignore.d.ts

@@ -0,0 +1 @@
+export declare function writeGitignore(projectPath: string): Promise<void>;

package/dist/steps/write-manifest-json.d.ts

@@ -0,0 +1 @@
+export declare function writeManifestJson(projectPath: string, projectName: string): Promise<void>;

package/dist/steps/write-package-json.d.ts

@@ -0,0 +1,6 @@
+interface OverridePackageJsonOptions {
+    template: string;
+    cliVersion?: string;
+}
+export declare function overridePackageJson(projectPath: string, projectName: string, { template, cliVersion }: OverridePackageJsonOptions): Promise<void>;
+export {};

package/dist/steps/write-readme-file.d.ts

@@ -0,0 +1 @@
+export declare function writeReadmeFile(projectPath: string, projectName: string): Promise<void>;

package/dist/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;

package/package.json

@@ -0,0 +1,85 @@
+{
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cezaraugusto/extension.git",
+    "directory": "programs/create"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/module.d.ts",
+      "import": "./dist/module.js",
+      "require": "./dist/module.js"
+    }
+  },
+  "main": "./dist/module.js",
+  "types": "./dist/module.d.ts",
+  "files": [
+    "dist"
+  ],
+  "name": "extension-create",
+  "version": "0.0.0-next-20250827130329",
+  "description": "The create step of Extension.js",
+  "author": {
+    "name": "Cezar Augusto",
+    "email": "boss@cezaraugusto.net",
+    "url": "https://cezaraugusto.com"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org",
+    "tag": "latest"
+  },
+  "keywords": [
+    "webextension",
+    "browser-extension",
+    "manifest-v3",
+    "mv3",
+    "cross-browser",
+    "scaffold",
+    "generator",
+    "project-generator",
+    "create-extension",
+    "create-browser-extension",
+    "starter-template",
+    "template",
+    "templates",
+    "starter-kit",
+    "boilerplate",
+    "init",
+    "bootstrap",
+    "chrome-extension",
+    "firefox-extension",
+    "edge-extension"
+  ],
+  "dependencies": {
+    "adm-zip": "^0.5.12",
+    "axios": "^1.7.2",
+    "cross-spawn": "^7.0.6",
+    "go-git-it": "^5.0.0",
+    "package-manager-detector": "^0.2.7",
+    "pintor": "0.3.0",
+    "tiny-glob": "^0.2.9"
+  },
+  "devDependencies": {
+    "@rslib/core": "^0.6.9",
+    "@types/cross-spawn": "^6.0.6",
+    "@types/node": "^22.10.1",
+    "@vitest/coverage-v8": "3.2.2",
+    "globals": "^15.13.0",
+    "tsconfig": "*",
+    "typescript": "5.7.2",
+    "vitest": "3.2.2"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "watch": "rslib build --watch",
+    "compile": "rslib build",
+    "pretest:create": "pnpm compile",
+    "test:create": "vitest run",
+    "test:coverage": "vitest run --coverage"
+  }
+}