extension-create 4.0.16 → 4.0.17

package/dist/lib/messages.d.ts

@@ -4,8 +4,6 @@ export declare function noProjectName(): string;
 export declare function noUrlAllowed(): string;
 export declare function successfullInstall(projectPath: string, projectName: string, depsInstalled: boolean): 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: unknown): string;
 export declare function writingTypeDefinitions(projectName: string): string;
 export declare function writingTypeDefinitionsError(error: unknown): string;
@@ -33,6 +31,5 @@ export declare function writingManifestJsonMetadataError(projectName: string, er
 export declare function writingReadmeMetaData(): string;
 export declare function writingGitIgnore(): string;
 export declare function writingReadmeMetaDataEError(projectName: string, error: unknown): string;
-export declare function folderExists(projectName: string): string;
 export declare function writingDirectoryError(error: unknown): string;
 export declare function cantSetupBuiltInTests(projectName: string, error: unknown): string;

package/dist/lib/messaging.d.ts

@@ -0,0 +1,180 @@
+export type Channel = 'info' | 'success' | 'warn' | 'error' | 'debug';
+export declare function isDebug(): boolean;
+export declare function prefix(type: Channel): string;
+export declare const fmt: {
+    heading: (title: string) => string;
+    label: (key: string) => string;
+    val: (value: string) => string;
+    code: (value: string) => string;
+    bullet: (value: string) => string;
+    block(title: string, rows: Array<[string, string]>): string;
+    truncate(input: unknown, max?: number): string;
+};
+export interface CardRow {
+    label: string;
+    value?: string;
+}
+export interface CardInput {
+    version?: string;
+    suffix?: string;
+    rows?: CardRow[];
+}
+export declare function card(input?: CardInput): string;
+export declare function isCardKeyClaimed(key: string): boolean;
+export declare function claimCardKey(key: string): boolean;
+export declare function artifactNoun(browser: string): 'Add-on' | 'Extension';
+export declare const ENVELOPE_SCHEMA = 1;
+export declare const CODES: {
+    readonly E_ARGS: 'E_ARGS';
+    readonly E_PROJECT_NOT_FOUND: 'E_PROJECT_NOT_FOUND';
+    readonly E_MANIFEST_NOT_FOUND: 'E_MANIFEST_NOT_FOUND';
+    readonly E_MANIFEST_INVALID: 'E_MANIFEST_INVALID';
+    readonly E_FIRST_COMPILE: 'E_FIRST_COMPILE';
+    readonly E_COMPILE: 'E_COMPILE';
+    readonly E_BROWSER_NOT_FOUND: 'E_BROWSER_NOT_FOUND';
+    readonly E_BROWSER_LAUNCH: 'E_BROWSER_LAUNCH';
+    readonly E_PROFILE_LOCKED: 'E_PROFILE_LOCKED';
+    readonly E_READY_TIMEOUT: 'E_READY_TIMEOUT';
+    readonly E_SESSION_EXISTS: 'E_SESSION_EXISTS';
+    readonly E_CONTROL_DENIED: 'E_CONTROL_DENIED';
+    readonly E_CONTROL_UNAVAILABLE: 'E_CONTROL_UNAVAILABLE';
+    readonly E_TOKEN_MISSING: 'E_TOKEN_MISSING';
+    readonly E_NETWORK: 'E_NETWORK';
+    readonly E_INTERRUPTED: 'E_INTERRUPTED';
+    readonly E_NOT_IMPLEMENTED: 'E_NOT_IMPLEMENTED';
+    readonly E_INTERNAL: 'E_INTERNAL';
+    readonly E_UNSUPPORTED_BROWSER: 'E_UNSUPPORTED_BROWSER';
+    readonly E_INVALID_OPTION: 'E_INVALID_OPTION';
+    readonly E_PORT_UNAVAILABLE: 'E_PORT_UNAVAILABLE';
+    readonly E_DEPENDENCY_INSTALL: 'E_DEPENDENCY_INSTALL';
+    readonly E_TEMPLATE_NOT_FOUND: 'E_TEMPLATE_NOT_FOUND';
+    readonly E_DESTINATION_NOT_EMPTY: 'E_DESTINATION_NOT_EMPTY';
+    readonly E_DESTINATION_NOT_WRITABLE: 'E_DESTINATION_NOT_WRITABLE';
+    readonly E_BROWSER_DOWNLOAD: 'E_BROWSER_DOWNLOAD';
+    readonly E_SESSION_NOT_FOUND: 'E_SESSION_NOT_FOUND';
+    readonly E_EVAL_REFUSED: 'E_EVAL_REFUSED';
+    readonly E_TARGET_NOT_FOUND: 'E_TARGET_NOT_FOUND';
+    readonly E_TIMEOUT: 'E_TIMEOUT';
+    readonly E_PUBLISH_REJECTED: 'E_PUBLISH_REJECTED';
+    readonly E_AUTH_REQUIRED: 'E_AUTH_REQUIRED';
+    readonly E_SAFARI_TOOLCHAIN: 'E_SAFARI_TOOLCHAIN';
+    readonly E_EVAL: 'E_EVAL';
+    readonly E_INSPECT: 'E_INSPECT';
+    readonly E_STORAGE: 'E_STORAGE';
+    readonly E_LOGS_NOT_FOUND: 'E_LOGS_NOT_FOUND';
+    readonly E_READY_ERROR_STATUS: 'E_READY_ERROR_STATUS';
+    readonly E_COMMAND_UNSUPPORTED_FOR_TARGET: 'E_COMMAND_UNSUPPORTED_FOR_TARGET';
+    readonly E_FLAG_VALUE_INVALID: 'E_FLAG_VALUE_INVALID';
+    readonly E_FLAG_NOT_SUPPORTED_HERE: 'E_FLAG_NOT_SUPPORTED_HERE';
+    readonly E_DEV_SERVER_START: 'E_DEV_SERVER_START';
+    readonly E_DOCTOR_CHECKS_FAILED: 'E_DOCTOR_CHECKS_FAILED';
+    readonly E_TELEMETRY_WRITE: 'E_TELEMETRY_WRITE';
+    readonly E_PREVIEW_NO_DIST: 'E_PREVIEW_NO_DIST';
+    readonly E_BROWSER_UNINSTALL: 'E_BROWSER_UNINSTALL';
+    readonly E_NODE_VERSION: 'E_NODE_VERSION';
+    readonly E_UNKNOWN_COMMAND: 'E_UNKNOWN_COMMAND';
+    readonly E_REMOVED_FLAG: 'E_REMOVED_FLAG';
+    readonly E_BROWSER_NOT_INSTALLABLE: 'E_BROWSER_NOT_INSTALLABLE';
+    readonly E_PARENT_GONE: 'E_PARENT_GONE';
+    readonly E_REMOTE_URL_UNSUPPORTED: 'E_REMOTE_URL_UNSUPPORTED';
+    readonly E_CONFIG_LOAD: 'E_CONFIG_LOAD';
+    readonly E_MANAGED_DEP_CONFLICT: 'E_MANAGED_DEP_CONFLICT';
+    readonly E_TYPES_EMIT: 'E_TYPES_EMIT';
+    readonly E_TSCONFIG_MISSING: 'E_TSCONFIG_MISSING';
+    readonly E_OPTIONAL_DEP_UNRESOLVED: 'E_OPTIONAL_DEP_UNRESOLVED';
+    readonly E_OPTIONAL_DEP_LOAD: 'E_OPTIONAL_DEP_LOAD';
+    readonly E_OPTIONAL_DEP_UNKNOWN: 'E_OPTIONAL_DEP_UNKNOWN';
+    readonly E_COMPANION_EXTENSION_PATH: 'E_COMPANION_EXTENSION_PATH';
+    readonly E_MANIFEST_IN_PUBLIC: 'E_MANIFEST_IN_PUBLIC';
+    readonly E_RUNTIME_NOT_FOUND: 'E_RUNTIME_NOT_FOUND';
+    readonly E_MANIFEST_SHAPE: 'E_MANIFEST_SHAPE';
+    readonly E_MANIFEST_PAGE_MISSING: 'E_MANIFEST_PAGE_MISSING';
+    readonly E_MANIFEST_VERSION_UNSUPPORTED: 'E_MANIFEST_VERSION_UNSUPPORTED';
+    readonly E_MANIFEST_LOAD_BLOCKERS: 'E_MANIFEST_LOAD_BLOCKERS';
+    readonly E_MANIFEST_PERMISSION_MISSING: 'E_MANIFEST_PERMISSION_MISSING';
+    readonly E_MANIFEST_MSG_KEY_MISSING: 'E_MANIFEST_MSG_KEY_MISSING';
+    readonly E_MANIFEST_EMIT: 'E_MANIFEST_EMIT';
+    readonly E_RESTART_REQUIRED: 'E_RESTART_REQUIRED';
+    readonly E_COMPILE_FATAL: 'E_COMPILE_FATAL';
+    readonly E_MODULE_NOT_FOUND: 'E_MODULE_NOT_FOUND';
+    readonly E_ENTRY_NOT_FOUND: 'E_ENTRY_NOT_FOUND';
+    readonly E_ASSET_MISSING: 'E_ASSET_MISSING';
+    readonly E_SCRIPT_DEP_MISSING: 'E_SCRIPT_DEP_MISSING';
+    readonly E_RESERVED_FOLDER: 'E_RESERVED_FOLDER';
+    readonly E_CSS_PARSE: 'E_CSS_PARSE';
+    readonly E_CSS_PREPROCESSOR_MISSING: 'E_CSS_PREPROCESSOR_MISSING';
+    readonly E_CSS_DEAD_REF: 'E_CSS_DEAD_REF';
+    readonly E_INTEGRATION_INSTALL: 'E_INTEGRATION_INSTALL';
+    readonly E_POLYFILL_NOT_FOUND: 'E_POLYFILL_NOT_FOUND';
+    readonly E_LOCALES_LAYOUT: 'E_LOCALES_LAYOUT';
+    readonly E_WAR_INVALID: 'E_WAR_INVALID';
+    readonly E_MATCH_PATTERN_INVALID: 'E_MATCH_PATTERN_INVALID';
+    readonly E_BACKGROUND_REQUIRED: 'E_BACKGROUND_REQUIRED';
+    readonly E_CONTENT_SCRIPT_SYNTAX: 'E_CONTENT_SCRIPT_SYNTAX';
+    readonly E_NO_ENTRYPOINTS: 'E_NO_ENTRYPOINTS';
+    readonly E_REMOTE_RESOURCE_BLOCKED: 'E_REMOTE_RESOURCE_BLOCKED';
+    readonly E_PERF_BUDGET: 'E_PERF_BUDGET';
+    readonly E_ZIP_SKIPPED: 'E_ZIP_SKIPPED';
+    readonly E_ENV_NO_MATCH: 'E_ENV_NO_MATCH';
+    readonly E_REMOTE_FETCH_TIMEOUT: 'E_REMOTE_FETCH_TIMEOUT';
+    readonly E_REMOTE_DOWNLOAD: 'E_REMOTE_DOWNLOAD';
+    readonly E_REMOTE_ZIP_INVALID: 'E_REMOTE_ZIP_INVALID';
+    readonly E_LOCAL_ZIP_NOT_FOUND: 'E_LOCAL_ZIP_NOT_FOUND';
+    readonly E_PROJECT_DOWNLOAD_EMPTY: 'E_PROJECT_DOWNLOAD_EMPTY';
+    readonly E_BROWSER_BINARY_REQUIRED: 'E_BROWSER_BINARY_REQUIRED';
+    readonly E_BROWSER_BINARY_INVALID: 'E_BROWSER_BINARY_INVALID';
+    readonly E_BROWSER_EXITED: 'E_BROWSER_EXITED';
+    readonly E_BROWSER_START_TIMEOUT: 'E_BROWSER_START_TIMEOUT';
+    readonly E_LAUNCH_SKIPPED_COMPILE_ERRORS: 'E_LAUNCH_SKIPPED_COMPILE_ERRORS';
+    readonly E_INSTANCE_AMBIGUOUS: 'E_INSTANCE_AMBIGUOUS';
+    readonly E_WSL_INTEROP: 'E_WSL_INTEROP';
+    readonly E_EXTENSION_LOAD_REFUSED: 'E_EXTENSION_LOAD_REFUSED';
+    readonly E_ADDON_INSTALL: 'E_ADDON_INSTALL';
+    readonly E_BROWSER_CONNECT: 'E_BROWSER_CONNECT';
+    readonly E_BROWSER_CONNECTION_CLOSED: 'E_BROWSER_CONNECTION_CLOSED';
+    readonly E_CDP_NOT_CONNECTED: 'E_CDP_NOT_CONNECTED';
+    readonly E_CDP_TIMEOUT: 'E_CDP_TIMEOUT';
+    readonly E_CDP_OP_FAILED: 'E_CDP_OP_FAILED';
+    readonly E_EXTENSION_ID_UNKNOWN: 'E_EXTENSION_ID_UNKNOWN';
+    readonly E_RDP_PROTOCOL: 'E_RDP_PROTOCOL';
+    readonly E_DEV_SERVER_TIMEOUT: 'E_DEV_SERVER_TIMEOUT';
+    readonly E_PORT_IN_USE: 'E_PORT_IN_USE';
+    readonly E_SESSION_STOPPED: 'E_SESSION_STOPPED';
+    readonly E_LOGS_STREAM_GAP: 'E_LOGS_STREAM_GAP';
+    readonly E_CREATE_DIR: 'E_CREATE_DIR';
+    readonly E_CREATE_WRITE: 'E_CREATE_WRITE';
+    readonly E_CREATE_TESTS_SETUP: 'E_CREATE_TESTS_SETUP';
+    readonly E_GIT_SKIPPED: 'E_GIT_SKIPPED';
+    readonly E_BROWSER_INSTALL_PRIVILEGE: 'E_BROWSER_INSTALL_PRIVILEGE';
+    readonly E_UNINSTALL_NOOP: 'E_UNINSTALL_NOOP';
+};
+export type ErrorCode = (typeof CODES)[keyof typeof CODES];
+export interface EnvelopeError {
+    code: ErrorCode;
+    message: string;
+    name?: string;
+    engine?: string;
+    hint?: string;
+}
+export interface Envelope<T = unknown> {
+    schema: typeof ENVELOPE_SCHEMA;
+    ok: boolean;
+    command: string;
+    status: string;
+    value: T | null;
+    error: EnvelopeError | null;
+    truncated?: boolean;
+    hint?: string;
+    warnings: string[];
+}
+export interface EnvelopeExtras {
+    hint?: string;
+    warnings?: string[];
+    truncated?: boolean;
+    value?: unknown;
+}
+export declare const ENVELOPE: {
+    schema: number;
+    ok<T>(command: string, status: string, value: T, extras?: EnvelopeExtras): Envelope<T>;
+    fail(command: string, status: string, error: EnvelopeError, extras?: EnvelopeExtras): Envelope;
+};

package/dist/lib/utils.d.ts

@@ -1,7 +1,7 @@
 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<import("prefers-yarn").PackageManagerName>;
-export declare function isDirectoryWriteable(directory: string, projectName: string, logger: {
+export declare function isDirectoryWriteable(directory: string, logger: {
     log(...args: unknown[]): void;
     error(...args: unknown[]): void;
 }): Promise<boolean>;

package/dist/module.cjs

@@ -45,6 +45,71 @@ __webpack_require__.d(__webpack_exports__, {
 const external_node_path_namespaceObject = require("node:path");
 const external_pintor_namespaceObject = require("pintor");
 var external_pintor_default = /*#__PURE__*/ __webpack_require__.n(external_pintor_namespaceObject);
+const GLYPH = '⏵⏵⏵';
+const DEBUG_GLYPH = '···';
+const DEBUG_VALUES = new Set([
+    '1',
+    'true',
+    'yes',
+    'on',
+    'debug',
+    'dev',
+    'development'
+]);
+function isDebug() {
+    const raw = process.env.EXTENSION_DEBUG ?? process.env.EXTENSION_AUTHOR_MODE;
+    return DEBUG_VALUES.has(String(raw ?? '').trim().toLowerCase());
+}
+function prefix(type) {
+    if ('error' === type) return external_pintor_default().red(GLYPH);
+    if ('warn' === type) return external_pintor_default().brightYellow(GLYPH);
+    if ('success' === type) return external_pintor_default().green(GLYPH);
+    if ('debug' === type) return external_pintor_default().dim(external_pintor_default().gray(DEBUG_GLYPH));
+    return external_pintor_default().gray(GLYPH);
+}
+const fmt = {
+    heading: (title)=>external_pintor_default().underline(external_pintor_default().blue(title)),
+    label: (key)=>external_pintor_default().gray(key.toUpperCase()),
+    val: (value)=>external_pintor_default().underline(value),
+    code: (value)=>external_pintor_default().blue(value),
+    bullet: (value)=>`- ${value}`,
+    block (title, rows) {
+        const head = fmt.heading(title);
+        const body = rows.map(([key, value])=>`${fmt.label(key)} ${value}`).join('\n');
+        return `${head}\n${body}`;
+    },
+    truncate (input, max = 800) {
+        const s = (()=>{
+            try {
+                return 'string' == typeof input ? input : JSON.stringify(input);
+            } catch  {
+                return String(input);
+            }
+        })();
+        return s.length > max ? `${s.slice(0, max)}…` : s;
+    }
+};
+const CARD_LABEL_WIDTH = 15;
+function card(input = {}) {
+    const version = String(input.version || '').trim();
+    const suffix = String(input.suffix || '').trim();
+    const head = ` 🧩 ${external_pintor_default().brightBlue('Extension.js')}` + (version ? ` ${external_pintor_default().gray(version)}` : '') + (suffix ? ` ${suffix}` : '');
+    const body = (input.rows || []).filter((row)=>String(row.value || '').trim().length > 0).map((row)=>{
+        const label = row.label.padEnd(CARD_LABEL_WIDTH);
+        return `    ${label}${external_pintor_default().gray(String(row.value).trim())}`;
+    });
+    return [
+        head,
+        ...body
+    ].join('\n');
+}
+new Set([
+    'firefox',
+    'firefox-based',
+    'gecko-based',
+    'librewolf',
+    'waterfox'
+]);
 const external_prefers_yarn_namespaceObject = require("prefers-yarn");
 function isDenoRuntime() {
     return void 0 !== globalThis.Deno || Boolean(process.versions?.deno);
@@ -53,23 +118,22 @@ function resolveScaffoldPackageManager() {
     if (isDenoRuntime()) return 'deno';
     return (0, external_prefers_yarn_namespaceObject.detectPackageManagerFromEnv)();
 }
-const statusPrefix = external_pintor_default().brightBlue('⏵⏵⏵');
 function destinationNotWriteable(workingDir) {
     const workingDirFolder = external_node_path_namespaceObject.basename(workingDir);
-    return `${external_pintor_default().red('Error')} Couldn't write to the destination directory.\n${external_pintor_default().red('Next step: choose a writable path or update folder permissions.')}\n${external_pintor_default().red('Path')} ${external_pintor_default().underline(workingDirFolder)}`;
+    return `${prefix('error')} Couldn't write to the destination directory.\n${external_pintor_default().red('Choose a writable path, or update the folder permissions.')}\n${fmt.label('PATH')} ${fmt.val(workingDirFolder)}`;
 }
 async function directoryHasConflicts(projectPath, conflictingFiles) {
     const projectName = external_node_path_namespaceObject.basename(projectPath);
-    let message = `Conflicting files found in ${external_pintor_default().blue(projectName)}.\n\n`;
+    let message = `${prefix('error')} ${external_pintor_default().blue(projectName)} already contains files that would be overwritten.\n${external_pintor_default().red('Remove or rename them, or choose a different directory name.')}\n\n`;
     for (const file of conflictingFiles)message += `   ${external_pintor_default().yellow('-')} ${external_pintor_default().yellow(file)}\n`;
-    message += `\n${external_pintor_default().red('Next step: remove or rename the files above, or choose a different directory name.')}\n\nPath: ${external_pintor_default().underline(projectPath)}`;
+    message += `\n${fmt.label('PATH')} ${fmt.val(projectPath)}`;
     return message;
 }
 function noProjectName() {
-    return `${external_pintor_default().red('Error')} Project name is required.\nNext step: provide a project name (for example, ${external_pintor_default().blue('my-extension')}) or run ${external_pintor_default().blue('--help')} for usage.`;
+    return `${prefix('error')} A project name is required.\n${external_pintor_default().red('Pass a name, for example')} ${external_pintor_default().blue('extension create my-extension')}.\n${external_pintor_default().red('Run')} ${external_pintor_default().blue('extension create --help')} ${external_pintor_default().red('for the full usage.')}`;
 }
 function noUrlAllowed() {
-    return `${external_pintor_default().red('Error')} URLs are not allowed as a project path.\nNext step: provide a project name or a local directory path.`;
+    return `${prefix('error')} A URL is not a valid project path.\n${external_pintor_default().red('Pass a project name or a local directory path.')}`;
 }
 async function successfullInstall(projectPath, projectName, depsInstalled) {
     const relativePath = external_node_path_namespaceObject.relative(process.cwd(), projectPath);
@@ -97,116 +161,107 @@ async function successfullInstall(projectPath, projectName, depsInstalled) {
             command = 'npm run dev';
             installCmd = 'npm install';
     }
-    const steps = depsInstalled ? `  1. ${external_pintor_default().blue('cd')} ${external_pintor_default().underline(relativePath)}\n  2. ${external_pintor_default().blue(command)} (runs a fresh browser profile with your extension loaded)\n` : `  1. ${external_pintor_default().blue('cd')} ${external_pintor_default().underline(relativePath)}\n  2. ${external_pintor_default().blue(installCmd)}\n  3. ${external_pintor_default().blue(command)} (runs a fresh browser profile with your extension loaded)\n`;
-    const depsNote = depsInstalled ? `\n${external_pintor_default().gray('Dependencies installed. You can start developing now.')}\n` : '\n';
-    return `${statusPrefix} ${external_pintor_default().green('Created')} ${external_pintor_default().blue(projectName)}\n\nNext steps:\n\n` + steps + depsNote;
+    const runNote = `     ${external_pintor_default().gray('Run the extension in a fresh browser profile.')}\n`;
+    const steps = depsInstalled ? `  1. ${external_pintor_default().blue('cd')} ${fmt.val(relativePath)}\n  2. ${external_pintor_default().blue(command)}\n` + runNote : `  1. ${external_pintor_default().blue('cd')} ${fmt.val(relativePath)}\n  2. ${external_pintor_default().blue(installCmd)}\n  3. ${external_pintor_default().blue(command)}\n` + runNote;
+    return `${prefix('success')} ${external_pintor_default().blue(projectName)} is ready.\n\nNext steps:\n` + steps;
 }
 function startingNewExtension(projectName) {
-    return `${statusPrefix} Creating ${external_pintor_default().blue(projectName)}...`;
-}
-function checkingIfPathIsWriteable() {
-    return `${statusPrefix} Checking if the destination path is writable...`;
-}
-function scanningPossiblyConflictingFiles() {
-    return `${statusPrefix} Scanning for conflicting files...`;
+    return `${prefix('info')} Create the extension ${external_pintor_default().blue(projectName)}.`;
 }
 function createDirectoryError(projectName, error) {
-    return `${external_pintor_default().red('Error')} Couldn't create directory ${external_pintor_default().blue(projectName)}.\n${external_pintor_default().red(String(error))}\n${external_pintor_default().red('Next step: check the path and permissions, then try again.')}`;
+    return `${prefix('error')} Couldn't create the directory ${external_pintor_default().blue(projectName)}.\n${external_pintor_default().red('Check the path and its permissions, then try again.')}\n${external_pintor_default().red(String(error))}`;
 }
 function writingTypeDefinitions(projectName) {
-    return `${statusPrefix} Writing type definitions for ${external_pintor_default().blue(projectName)}...`;
+    return `${prefix('debug')} create types name=${projectName}`;
 }
 function writingTypeDefinitionsError(error) {
-    return `${external_pintor_default().red('Error')} Couldn't write the extension type definitions.\n${external_pintor_default().red(String(error))}\n${external_pintor_default().red('Next step: check file permissions, then try again.')}`;
+    return `${prefix('error')} Couldn't write the extension type definitions.\n${external_pintor_default().red('Check the file permissions, then try again.')}\n${external_pintor_default().red(String(error))}`;
 }
 function installingFromTemplate(projectName, templateName) {
-    if ('init' === templateName || "javascript" === templateName) return `${statusPrefix} Installing ${external_pintor_default().blue(projectName)}...`;
-    return `${statusPrefix} Installing ${external_pintor_default().blue(projectName)} from template ${external_pintor_default().yellow(templateName)}...`;
+    if ('init' === templateName || "javascript" === templateName) return `${prefix('info')} Install ${external_pintor_default().blue(projectName)}.`;
+    return `${prefix('info')} Install ${external_pintor_default().blue(projectName)} from the template ${external_pintor_default().yellow(templateName)}.`;
 }
 function installingFromTemplateError(projectName, template, error) {
-    return `${external_pintor_default().red('Error')} Couldn't find template ${external_pintor_default().yellow(template)} for ${external_pintor_default().blue(projectName)}.\n${external_pintor_default().red(String(error))}\n${external_pintor_default().red('Next step: choose a valid template name or URL.')}`;
+    return `${prefix('error')} Couldn't find the template ${external_pintor_default().yellow(template)}.\n${external_pintor_default().red('Choose a template name from')} ${external_pintor_default().blue('extension create --help')}${external_pintor_default().red(', or pass a GitHub URL.')}\n${external_pintor_default().red(String(error))}`;
 }
 function templateFetchTimedOut(templateName, ms) {
-    return `${external_pintor_default().red('Error')} Timed out after ${external_pintor_default().yellow(`${Math.round(ms / 1000)}s`)} fetching template ${external_pintor_default().yellow(templateName)}.\n${external_pintor_default().red('Next step: check your network, or set EXTENSION_CREATE_TIMEOUT_MS to allow more time.')}`;
+    return `${prefix('error')} Timed out after ${external_pintor_default().yellow(`${Math.round(ms / 1000)}s`)} fetching the template ${external_pintor_default().yellow(templateName)}.\n${external_pintor_default().red('Check your network connection.')}\n${external_pintor_default().red('Set EXTENSION_CREATE_TIMEOUT_MS to allow more time.')}`;
 }
 function templateNotFoundInCatalog(templateName, error) {
-    return `${external_pintor_default().red('Error')} Template ${external_pintor_default().yellow(templateName)} is not in the extension-js/examples catalog.\n` + (error ? `${external_pintor_default().red(String(error))}\n` : '') + `${external_pintor_default().red('Next step: run')} ${external_pintor_default().yellow('extension create --help')} ` + `${external_pintor_default().red('to list valid template names, or pass a GitHub URL.')}`;
+    return `${prefix('error')} The template ${external_pintor_default().yellow(templateName)} is not in the extension-js/examples catalog.\n${external_pintor_default().red('Run')} ${external_pintor_default().blue('extension create --help')} ${external_pintor_default().red('to list the valid template names.')}\n${external_pintor_default().red('Or pass a GitHub URL to use a template from anywhere.')}` + (error ? `\n${external_pintor_default().red(String(error))}` : '');
 }
 function templateDownloadFailed(templateName, error) {
-    return `${external_pintor_default().red('Error')} Couldn't download template ${external_pintor_default().yellow(templateName)} from ${external_pintor_default().yellow('github.com/extension-js/examples')}.\n${external_pintor_default().red(String(error?.message || error))}\n${external_pintor_default().red('Next step: check your network (or GitHub rate limits) and try again; set EXTENSION_CREATE_TIMEOUT_MS to allow more time.')}`;
+    return `${prefix('error')} Couldn't download the template ${external_pintor_default().yellow(templateName)} from ${external_pintor_default().yellow('github.com/extension-js/examples')}.\n${external_pintor_default().red('Check your network connection and any GitHub rate limit, then try again.')}\n${external_pintor_default().red('Set EXTENSION_CREATE_TIMEOUT_MS to allow more time.')}\n${external_pintor_default().red(String(error?.message || error))}`;
 }
 function initializingGitForRepository(projectName) {
-    return `${statusPrefix} Initializing git repository for ${external_pintor_default().blue(projectName)}...`;
+    return `${prefix('debug')} create git init name=${projectName}`;
 }
 function initializingGitSkipped(projectName, reason) {
-    return `${statusPrefix} Skipped git init for ${external_pintor_default().blue(projectName)} (${external_pintor_default().yellow(reason)}). Run ${external_pintor_default().yellow('git init')} yourself if you want version control.`;
+    return `${prefix('warn')} Skip the git init for ${external_pintor_default().blue(projectName)}.\n${fmt.label('REASON')} ${external_pintor_default().yellow(reason)}\nRun ${external_pintor_default().yellow('git init')} yourself if you want version control.`;
 }
 function installingDependencies() {
-    return `${statusPrefix} Installing project-specific dependencies... ${external_pintor_default().gray('(This may take a moment)')}`;
+    return `${prefix('info')} Install the project dependencies.\n${external_pintor_default().gray('This can take a moment.')}`;
 }
 function foundSpecializedDependencies(count) {
-    return `${statusPrefix} Found ${external_pintor_default().yellow(String(count))} specialized integration${1 === count ? '' : 's'} needing installation...`;
+    return `${prefix('debug')} create integrations count=${count}`;
 }
 function installingProjectIntegrations(integrations) {
-    if (0 === integrations.length) return `${statusPrefix} Installing specialized dependencies for ${external_pintor_default().gray('project tooling')}... ${external_pintor_default().gray('(This may take a moment)')}`;
+    if (0 === integrations.length) return `${prefix('info')} Install the dependencies for the ${external_pintor_default().gray('project tooling')}.\n${external_pintor_default().gray('This can take a moment.')}`;
     const formatList = (items)=>{
         if (1 === items.length) return items[0];
         if (2 === items.length) return `${items[0]} and ${items[1]}`;
         return `${items.slice(0, -1).join(', ')}, and ${items[items.length - 1]}`;
     };
     const tools = formatList(integrations.map((name)=>external_pintor_default().yellow(name)));
-    return `${statusPrefix} Installing specialized dependencies for ${tools}... ${external_pintor_default().gray('(This may take a moment)')}`;
+    return `${prefix('info')} Install the dependencies for ${tools}.\n${external_pintor_default().gray('This can take a moment.')}`;
 }
 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.')}`;
+    return `${prefix('error')} The command ${external_pintor_default().yellow(gitCommand)} ${external_pintor_default().yellow(gitArgs.join(' '))} failed with exit code ${external_pintor_default().yellow(String(code))}.\n${external_pintor_default().red('Run it yourself to see the full 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.')}`;
+    return `${prefix('error')} The install process for ${external_pintor_default().blue(projectName)} exited unexpectedly.\n${external_pintor_default().red('Run the install command yourself to see the full error.')}\n${external_pintor_default().red(String(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.')}`;
+    return `${prefix('error')} Couldn't install the dependencies for ${external_pintor_default().blue(projectName)}.\n${external_pintor_default().red('Check your package manager settings, then try again.')}\n${external_pintor_default().red(String(error?.message || error))}`;
 }
 function writingPackageJsonMetadata() {
-    return `${statusPrefix} Writing ${external_pintor_default().yellow('package.json')}...`;
+    return `${prefix('debug')} create write file=package.json`;
 }
 function writingPackageJsonMetadataError(projectName, error) {
-    return `${external_pintor_default().red('Error')} Couldn't write ${external_pintor_default().yellow('package.json')} for ${external_pintor_default().blue(projectName)}.\n${external_pintor_default().red(String(error))}\n${external_pintor_default().red('Next step: check file permissions, then try again.')}`;
+    return `${prefix('error')} Couldn't write ${external_pintor_default().yellow('package.json')}.\n${external_pintor_default().red('Check the file permissions, then try again.')}\n${external_pintor_default().red(String(error))}`;
 }
 function writingDenoJsonc() {
-    return `${statusPrefix} Writing ${external_pintor_default().yellow('deno.jsonc')}...`;
+    return `${prefix('debug')} create write file=deno.jsonc`;
 }
 function writingDenoJsoncError(projectName, error) {
-    return `${external_pintor_default().red('Error')} Couldn't write ${external_pintor_default().yellow('deno.jsonc')} for ${external_pintor_default().blue(projectName)}.\n${external_pintor_default().red(String(error))}\n${external_pintor_default().red('Next step: check file permissions, then try again.')}`;
+    return `${prefix('error')} Couldn't write ${external_pintor_default().yellow('deno.jsonc')}.\n${external_pintor_default().red('Check the file permissions, then try again.')}\n${external_pintor_default().red(String(error))}`;
 }
 function writingTemplateProvenance() {
-    return `${statusPrefix} Writing ${external_pintor_default().yellow('.extension-create.json')}...`;
+    return `${prefix('debug')} create write file=.extension-create.json`;
 }
 function writingTemplateProvenanceError(error) {
-    return `${external_pintor_default().red('Warning')} Couldn't write ${external_pintor_default().yellow('.extension-create.json')} provenance (non-fatal).\n${external_pintor_default().red(String(error))}`;
+    return `${prefix('warn')} Couldn't write ${external_pintor_default().yellow('.extension-create.json')}.\nThe project is fine; only the template provenance record is missing.\n${external_pintor_default().yellow(String(error))}`;
 }
 function writingManifestJsonMetadata() {
-    return `${statusPrefix} Writing ${external_pintor_default().yellow('manifest.json')}...`;
+    return `${prefix('debug')} create write file=manifest.json`;
 }
 function writingManifestJsonMetadataError(projectName, error) {
-    return `${external_pintor_default().red('Error')} Couldn't write ${external_pintor_default().yellow('manifest.json')} for ${external_pintor_default().blue(projectName)}.\n${external_pintor_default().red(String(error))}\n${external_pintor_default().red('Next step: check file permissions, then try again.')}`;
+    return `${prefix('error')} Couldn't write ${external_pintor_default().yellow('manifest.json')}.\n${external_pintor_default().red('Check the file permissions, then try again.')}\n${external_pintor_default().red(String(error))}`;
 }
 function writingReadmeMetaData() {
-    return `${statusPrefix} Writing ${external_pintor_default().yellow('README.md')}...`;
+    return `${prefix('debug')} create write file=README.md`;
 }
 function writingGitIgnore() {
-    return `${statusPrefix} Writing ${external_pintor_default().yellow('.gitignore')}...`;
+    return `${prefix('debug')} create write file=.gitignore`;
 }
 function writingReadmeMetaDataEError(projectName, error) {
-    return `${external_pintor_default().red('Error')} Couldn't write ${external_pintor_default().yellow('README.md')} for ${external_pintor_default().blue(projectName)}.\n${external_pintor_default().red(String(error))}\n${external_pintor_default().red('Next step: check file permissions, then try again.')}`;
-}
-function folderExists(projectName) {
-    return `${statusPrefix} Ensuring ${external_pintor_default().blue(projectName)} exists...`;
+    return `${prefix('error')} Couldn't write ${external_pintor_default().yellow('README.md')}.\n${external_pintor_default().red('Check the file permissions, then try again.')}\n${external_pintor_default().red(String(error))}`;
 }
 function writingDirectoryError(error) {
-    return `${external_pintor_default().red('Error')} Couldn't check directory writability.\n${external_pintor_default().red(String(error))}\n${external_pintor_default().red('Next step: check the path and permissions, then try again.')}`;
+    return `${prefix('error')} Couldn't check whether the directory is writable.\n${external_pintor_default().red('Check the path and its permissions, then try again.')}\n${external_pintor_default().red(String(error))}`;
 }
 function cantSetupBuiltInTests(projectName, error) {
-    return `${external_pintor_default().red('Error')} Couldn't set up built-in tests for ${external_pintor_default().yellow(projectName)}.\n${external_pintor_default().red(String(error))}\n${external_pintor_default().red('Next step: run the setup step again or skip tests.')}`;
+    return `${prefix('error')} Couldn't set up the built-in tests.\n${external_pintor_default().red('The extension itself is fine. Re-run create, or skip the tests.')}\n${external_pintor_default().red(String(error))}`;
 }
 const promises_namespaceObject = require("node:fs/promises");
 async function copyDirectoryWithSymlinks(source, destination) {
@@ -278,15 +333,14 @@ async function moveDirectoryContents(source, destination) {
 async function getInstallCommand() {
     return (0, external_prefers_yarn_namespaceObject.detectPackageManagerFromEnv)();
 }
-async function isDirectoryWriteable(directory, projectName, logger) {
+async function isDirectoryWriteable(directory, logger) {
     try {
-        logger.log(folderExists(projectName));
         await promises_namespaceObject.mkdir(directory, {
             recursive: true
         });
         return true;
     } catch (err) {
-        logger.log(writingDirectoryError(err));
+        logger.error(writingDirectoryError(err));
         return false;
     }
 }
@@ -300,14 +354,12 @@ const allowlist = [
 async function createDirectory(projectPath, projectName, logger) {
     logger.log(startingNewExtension(projectName));
     try {
-        const isCurrentDirWriteable = await isDirectoryWriteable(projectPath, projectName, logger);
-        logger.log(checkingIfPathIsWriteable());
+        const isCurrentDirWriteable = await isDirectoryWriteable(projectPath, logger);
         if (!isCurrentDirWriteable) {
             logger.error(destinationNotWriteable(projectPath));
             throw new Error(destinationNotWriteable(projectPath));
         }
         const currentDir = await promises_namespaceObject.readdir(projectPath);
-        logger.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_node_path_namespaceObject.join(projectPath, file));
             return stats.isDirectory() ? `${file}/` : `${file}`;
@@ -338,7 +390,7 @@ async function generateExtensionTypes(projectPath, projectName, logger) {
         await promises_namespaceObject.mkdir(projectPath, {
             recursive: true
         });
-        logger.log(writingTypeDefinitions(projectName));
+        if (isDebug()) logger.log(writingTypeDefinitions(projectName));
         await promises_namespaceObject.writeFile(extensionEnvFile, fileContent);
     } catch (error) {
         logger.error(writingTypeDefinitionsError(error));
@@ -465,7 +517,7 @@ async function importFromExamplesCatalog(templateName, projectPath) {
     };
 }
 function isAuthorOrDevMode() {
-    return 'development' === process.env.EXTENSION_ENV || 'true' === process.env.EXTENSION_AUTHOR_MODE;
+    return 'development' === process.env.EXTENSION_ENV || isDebug();
 }
 async function withTimeout(task, ms, onTimeout) {
     let timer;
@@ -637,7 +689,7 @@ async function initializeGitRepository(projectPath, projectName, logger) {
         'init',
         '--quiet'
     ];
-    logger.log(initializingGitForRepository(projectName));
+    if (isDebug()) logger.log(initializingGitForRepository(projectName));
     const stdio = 'development' === process.env.EXTENSION_ENV ? 'inherit' : 'ignore';
     const child = (0, external_cross_spawn_namespaceObject.spawn)(gitCommand, gitArgs, {
         stdio,
@@ -1088,13 +1140,14 @@ async function installOptionalDependencies(developRoot, projectPath, plan, logge
     if (0 === plan.dependencies.length) return;
     const pm = (0, external_prefers_yarn_namespaceObject.detectPackageManagerFromEnv)();
     const stdio = 'development' === process.env.EXTENSION_ENV ? 'inherit' : 'ignore';
-    logger.log(foundSpecializedDependencies(plan.integrations.length));
+    if (isDebug()) logger.log(foundSpecializedDependencies(plan.integrations.length));
+    const infoPrefix = prefix('info');
     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 installMessage = baseMessage.replace(infoPrefix, `${infoPrefix} [${index + 1}/${plan.integrations.length}]`);
         logger.log(installMessage);
         if (0 === missingDeps.length) continue;
         const args = buildOptionalInstallArgs(pm, missingDeps, developRoot);
@@ -1263,7 +1316,7 @@ async function overridePackageJson(projectPath, projectName, { template = "javas
         }
     };
     try {
-        logger.log(writingPackageJsonMetadata());
+        if (isDebug()) logger.log(writingPackageJsonMetadata());
         await promises_namespaceObject.writeFile(external_node_path_namespaceObject.join(projectPath, 'package.json'), `${JSON.stringify(packageMetadata, null, 2)}\n`);
     } catch (error) {
         logger.error(writingPackageJsonMetadataError(projectName, error));
@@ -1320,7 +1373,7 @@ async function writeDenoJsonc(projectPath, projectName, { template = "javascript
     const tasks = getTemplateAwareScripts(template, extensionBinary);
     const imports = primary ? await collectTemplateImports(projectPath, cliVersion) : void 0;
     try {
-        logger.log(writingDenoJsonc());
+        if (isDebug()) logger.log(writingDenoJsonc());
         await promises_namespaceObject.writeFile(external_node_path_namespaceObject.join(projectPath, 'deno.jsonc'), renderDenoJsonc(tasks, imports));
         if (primary) await promises_namespaceObject.rm(external_node_path_namespaceObject.join(projectPath, 'package.json'), {
             force: true
@@ -1396,7 +1449,7 @@ async function writeGitignore(projectPath, logger) {
     const linesToAdd = globalLines.filter((line)=>!paths.has(line));
     while('' === linesToAdd[linesToAdd.length - 1])linesToAdd.pop();
     if (0 === linesToAdd.length) return;
-    logger.log(writingGitIgnore());
+    if (isDebug()) logger.log(writingGitIgnore());
     const shouldPrefixWithNewline = currentContents.length > 0 && !currentContents.endsWith('\n');
     const contentToAppend = `${shouldPrefixWithNewline ? '\n' : ''}${linesToAdd.join('\n')}`;
     await promises_namespaceObject.appendFile(gitIgnorePath, contentToAppend).catch((err)=>{
@@ -1457,7 +1510,7 @@ async function writeManifestJson(projectPath, projectName, logger) {
         author: 'Your Name'
     };
     try {
-        logger.log(writingManifestJsonMetadata());
+        if (isDebug()) logger.log(writingManifestJsonMetadata());
         await promises_namespaceObject.writeFile(manifestJsonPath, JSON.stringify(manifestMetadata, null, 2));
     } catch (error) {
         logger.error(writingManifestJsonMetadataError(projectName, error));
@@ -1486,7 +1539,7 @@ async function writeReadmeFile(projectPath, projectName, logger) {
     const blockquote = description ? `> ${description}\n\n` : '';
     const readme = `<a href="https://extension.js.org" target="_blank" rel="noopener noreferrer"><img src="https://img.shields.io/badge/Powered%20by%20%7C%20Extension.js-0971fe" alt="Powered by Extension.js" align="right" /></a>\n\n# ${projectName}\n\n` + blockquote + `${screenshotEmbed}` + `## Commands\n` + `\n` + `### dev\n` + `\n` + "Run the extension in development mode. Target a browser with `--browser`:\n" + `\n` + "```bash\n" + `${runPrefix} dev\n` + `${runPrefix} dev${argSeparator} --browser=firefox\n` + `${runPrefix} dev${argSeparator} --browser=edge\n` + "```\n" + `\n` + `### build\n` + `\n` + `Build for production. Convenience scripts target each browser:\n` + `\n` + "```bash\n" + `${runPrefix} build           # Chrome (default)\n` + `${runPrefix} build:firefox\n` + `${runPrefix} build:edge\n` + "```\n" + `\n` + `### preview\n` + `\n` + `Preview the production build in the browser:\n` + `\n` + "```bash\n" + `${runPrefix} preview\n` + "```\n" + `\n` + `## Learn more\n` + `\n` + `[Extension.js docs](https://extension.js.org).\n`;
     try {
-        logger.log(writingReadmeMetaData());
+        if (isDebug()) logger.log(writingReadmeMetaData());
         await promises_namespaceObject.mkdir(projectPath, {
             recursive: true
         });
@@ -1521,7 +1574,7 @@ async function writeTemplateProvenance(projectPath, provenance, logger) {
     if (!provenance?.template) return;
     const record = buildProvenanceRecord(provenance);
     try {
-        logger.log(writingTemplateProvenance());
+        if (isDebug()) logger.log(writingTemplateProvenance());
         await promises_namespaceObject.writeFile(external_node_path_namespaceObject.join(projectPath, TEMPLATE_PROVENANCE_FILE), `${JSON.stringify(record, null, 2)}\n`);
     } catch (error) {
         logger.error(writingTemplateProvenanceError(error));
@@ -1532,6 +1585,25 @@ async function extensionCreate(projectNameInput, { cliVersion, template = "javas
     if (projectNameInput.startsWith('http')) throw new Error(noUrlAllowed());
     const projectPath = external_node_path_namespaceObject.isAbsolute(projectNameInput) ? projectNameInput : external_node_path_namespaceObject.join(process.cwd(), projectNameInput);
     const projectName = external_node_path_namespaceObject.basename(projectPath);
+    const updateSuffix = process.env.EXTENSION_CLI_UPDATE_SUFFIX || '';
+    if (updateSuffix) delete process.env.EXTENSION_CLI_UPDATE_SUFFIX;
+    logger.log(' ');
+    logger.log(card({
+        version: cliVersion || process.env.EXTENSION_CLI_VERSION,
+        suffix: updateSuffix,
+        rows: [
+            {
+                label: 'Extension',
+                value: projectName
+            },
+            {
+                label: 'Output',
+                value: projectPath
+            }
+        ]
+    }));
+    logger.log(' ');
+    process.env.EXTENSION_CLI_BANNER_PRINTED = 'true';
     await createDirectory(projectPath, projectName, logger);
     const templateProvenance = await importExternalTemplate(projectPath, projectName, template, logger);
     const isMonorepoTemplate = String(template).toLowerCase().includes('monorepo');

package/dist/test-template-javascript/.extension-create.json

@@ -1,5 +1,5 @@
 {
-  "createdWith": "extension-create@4.0.15",
+  "createdWith": "extension-create@4.0.16",
   "template": "javascript",
   "source": "bundled"
 }

package/dist/test-template-javascript/package.json

@@ -21,7 +21,7 @@
   },
   "dependencies": {},
   "devDependencies": {
-    "extension": "^4.0.15"
+    "extension": "^4.0.16"
   },
   "packageManager": "pnpm@10.28.0",
   "pnpm": {

package/package.json

@@ -25,7 +25,7 @@
     "templates"
   ],
   "name": "extension-create",
-  "version": "4.0.16",
+  "version": "4.0.17",
   "description": "The standalone extension creation engine for Extension.js",
   "author": {
     "name": "Cezar Augusto",