@pixelated-tech/components 3.9.14 → 3.9.16

package/dist/components/config/config.js

@@ -22,6 +22,7 @@ export function getFullPixelatedConfig() {
         // If this library is installed as a package, check its dist/config as a fallback
         path.join(process.cwd(), 'node_modules', '@pixelated-tech', 'components', 'dist', 'config', filename),
     ];
+    // First, look for plaintext config files
     for (const configPath of paths) {
         if (fs.existsSync(configPath)) {
             try {
@@ -34,13 +35,46 @@ export function getFullPixelatedConfig() {
             }
         }
     }
+    // If not found, look for encrypted variants in the same locations (e.g., pixelated.config.json.enc)
+    const doIt = false;
+    if (!raw && doIt) {
+        for (const configPath of paths) {
+            const encPath = `${configPath}.enc`;
+            if (fs.existsSync(encPath)) {
+                try {
+                    raw = fs.readFileSync(encPath, 'utf8');
+                    source = encPath;
+                    break;
+                }
+                catch (err) {
+                    console.error(`Failed to read encrypted config file at ${encPath}`, err);
+                }
+            }
+        }
+    }
     if (!raw) {
         console.error('pixelated.config.json not found. Searched in src/app/config/, src/config/, and root.');
         return {};
     }
     // Handle decryption if the content is encrypted
     if (isEncrypted(raw)) {
-        const key = process.env.PIXELATED_CONFIG_KEY;
+        // Allow key to come from env or a local .env.local fallback (useful for local/CI debugging)
+        let key = process.env.PIXELATED_CONFIG_KEY;
+        if (!key) {
+            const envPath = path.join(process.cwd(), '.env.local');
+            if (fs.existsSync(envPath)) {
+                try {
+                    const envContent = fs.readFileSync(envPath, 'utf8');
+                    const match = envContent.match(/^PIXELATED_CONFIG_KEY=(.*)$/m);
+                    if (match && match[1]) {
+                        key = match[1].trim();
+                    }
+                }
+                catch (e) {
+                    // ignore
+                }
+            }
+        }
         if (!key) {
             console.error('PIXELATED_CONFIG is encrypted but PIXELATED_CONFIG_KEY is not set in the environment.');
             return {};

package/dist/config/pixelated.config.json.enc

@@ -1 +1 @@
-pxl:v1:d86199b0d8de38bec4e09834:31782f4ce4b3da8ef22b36edcd9306eb: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
+pxl:v1:1cf1822b5a08925a84ce42d5:4978c2e76935bd83c257792b8af5ff03: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

package/dist/scripts/config-vault.js

@@ -13,30 +13,22 @@ import { encrypt, decrypt, isEncrypted } from '../components/config/crypto';
  *  - `decrypt` writes atomically to the plain filename (when given a `.enc` file it writes to the base name)
  */
 const [, , command, targetPath, argKey] = process.argv;
+// Helper: obtain key from arg or env or .env.local (only used for encrypt/decrypt)
 let key = argKey || process.env.PIXELATED_CONFIG_KEY;
-// If key is still missing, try to load it from .env.local
 if (!key) {
     const envPath = path.join(process.cwd(), '.env.local');
     if (fs.existsSync(envPath)) {
-        const envContent = fs.readFileSync(envPath, 'utf8');
-        const match = envContent.match(/^PIXELATED_CONFIG_KEY=(.*)$/m);
-        if (match && match[1]) {
-            key = match[1].trim();
+        try {
+            const envContent = fs.readFileSync(envPath, 'utf8');
+            const match = envContent.match(/^PIXELATED_CONFIG_KEY=(.*)$/m);
+            if (match && match[1])
+                key = match[1].trim();
+        }
+        catch (e) {
+            // ignore
         }
     }
 }
-if (!command || !targetPath || !key) {
-    console.log('Usage:');
-    console.log('  encrypt <filePath> [key] - Encrypts the file and writes `<filePath>.enc`');
-    console.log('  decrypt <filePath> [key] - Decrypts the file and writes the plaintext file (atomic write)');
-    console.log('\nNote: Key can be passed as argument or via PIXELATED_CONFIG_KEY env var.');
-    process.exit(1);
-}
-const fullPath = path.isAbsolute(targetPath) ? targetPath : path.resolve(process.cwd(), targetPath);
-if (!fs.existsSync(fullPath)) {
-    console.error(`File not found: ${fullPath}`);
-    process.exit(1);
-}
 const atomicWrite = (destPath, data) => {
     const dir = path.dirname(destPath);
     const base = path.basename(destPath);
@@ -44,29 +36,148 @@ const atomicWrite = (destPath, data) => {
     fs.writeFileSync(tmp, data, 'utf8');
     fs.renameSync(tmp, destPath);
 };
+// Helper: print usage/help
+function printUsage() {
+    console.log('Usage:');
+    console.log('  npx tsx src/scripts/config-vault.ts encrypt <filePath> [key]   - Encrypts <filePath> (writes <filePath>.enc)');
+    console.log('  npx tsx src/scripts/config-vault.ts decrypt <filePath> [key]   - Decrypts <filePath>.enc and writes plaintext');
+    console.log('  npx tsx src/scripts/config-vault.ts postbuild                  - CI helper: decrypts and injects into .next/server');
+    console.log('\nNotes:');
+    console.log('  - Key can be passed as argument or via PIXELATED_CONFIG_KEY env var.');
+    console.log('  - Use PIXELATED_CONFIG_DEBUG=1 for verbose output during postbuild.');
+}
+// Helpful messages when arguments are missing
+if (!command) {
+    console.log('No command provided.');
+    printUsage();
+    process.exit(0);
+}
+if (command === 'help' || command === '--help' || command === '-h') {
+    printUsage();
+    process.exit(0);
+}
+// If encrypt/decrypt are requested, ensure targetPath and key exist; log informative messages
+if (command === 'encrypt' || command === 'decrypt') {
+    if (!targetPath) {
+        console.log('No target path provided for encrypt/decrypt.');
+        printUsage();
+        process.exit(1);
+    }
+    if (!key) {
+        // we attempted to resolve key from env/.env.local earlier; if still missing, inform the user
+        console.log('No key provided for encrypt/decrypt (argument, PIXELATED_CONFIG_KEY, or .env.local).');
+        printUsage();
+        process.exit(1);
+    }
+}
+/**
+ * Post-build behavior used by CI (Amplify):
+ * - Look for an encrypted config file in standard candidate locations
+ * - Validate PIXELATED_CONFIG_KEY (from env or .env.local)
+ * - Decrypt in-place and copy plaintext to .next/server/pixelated.config.json
+ * - Validate JSON and emit a concise success message
+ */
+function decryptPostBuild() {
+    const DEBUG = process.env.PIXELATED_CONFIG_DEBUG === '1';
+    const candidates = [
+        path.join(process.cwd(), 'src/app/config/pixelated.config.json.enc'),
+        path.join(process.cwd(), 'src/config/pixelated.config.json.enc'),
+        path.join(process.cwd(), 'src/pixelated.config.json.enc'),
+    ];
+    let foundEnc = null;
+    for (const p of candidates) {
+        if (fs.existsSync(p)) {
+            foundEnc = p;
+            break;
+        }
+    }
+    if (!foundEnc) {
+        if (DEBUG)
+            console.log('No encrypted config found; nothing to do.');
+        process.exit(0);
+    }
+    // Resolve key (env preferred, then .env.local)
+    let keyLocal = process.env.PIXELATED_CONFIG_KEY;
+    if (!keyLocal) {
+        const envPath = path.join(process.cwd(), '.env.local');
+        if (fs.existsSync(envPath)) {
+            try {
+                const envContent = fs.readFileSync(envPath, 'utf8');
+                const match = envContent.match(/^PIXELATED_CONFIG_KEY=(.*)$/m);
+                if (match && match[1])
+                    keyLocal = match[1].trim();
+            }
+            catch (e) {
+                // ignore
+            }
+        }
+    }
+    if (!keyLocal) {
+        console.error('PIXELATED_CONFIG_KEY not set; cannot decrypt config.');
+        process.exit(1);
+    }
+    if (!/^[0-9a-fA-F]{64}$/.test(keyLocal)) {
+        console.error('PIXELATED_CONFIG_KEY invalid: must be 64 hex characters.');
+        process.exit(1);
+    }
+    try {
+        const raw = fs.readFileSync(foundEnc, 'utf8');
+        if (!isEncrypted(raw)) {
+            console.error('Found file is not in encrypted format.');
+            process.exit(1);
+        }
+        const decrypted = decrypt(raw, keyLocal);
+        const dest = foundEnc.endsWith('.enc') ? foundEnc.slice(0, -4) : `${foundEnc}.plain`;
+        atomicWrite(dest, decrypted);
+        // Copy to .next/server for SSR to pick up
+        const injectPath = path.join(process.cwd(), '.next', 'server', 'pixelated.config.json');
+        fs.mkdirSync(path.dirname(injectPath), { recursive: true });
+        fs.copyFileSync(dest, injectPath);
+        // Validate JSON
+        JSON.parse(decrypted);
+        console.log('Config injected into .next/server/pixelated.config.json');
+        if (DEBUG)
+            console.log(`Decrypted ${path.basename(foundEnc)} -> ${injectPath}`);
+        process.exit(0);
+    }
+    catch (err) {
+        console.error(`Post-build decrypt failed: ${err.message}`);
+        process.exit(1);
+    }
+}
 try {
     if (command === 'encrypt') {
-        const content = fs.readFileSync(fullPath, 'utf8');
+        if (!key) {
+            console.error('Encryption key is required.');
+            process.exit(1);
+        }
+        const content = fs.readFileSync(targetPath, 'utf8');
         if (isEncrypted(content)) {
             console.log('File is already encrypted. No action taken.');
             process.exit(0);
         }
         const encrypted = encrypt(content, key);
-        const encPath = fullPath.endsWith('.enc') ? fullPath : `${fullPath}.enc`;
+        const encPath = targetPath.endsWith('.enc') ? targetPath : `${targetPath}.enc`;
         atomicWrite(encPath, encrypted);
         console.log(`Successfully encrypted ${targetPath} -> ${path.basename(encPath)}`);
     }
     else if (command === 'decrypt') {
-        const content = fs.readFileSync(fullPath, 'utf8');
+        if (!key) {
+            console.error('Decryption key is required.');
+            process.exit(1);
+        }
+        const content = fs.readFileSync(targetPath, 'utf8');
         if (!isEncrypted(content)) {
             console.log('File is not encrypted. No action taken.');
             process.exit(0);
         }
         const decrypted = decrypt(content, key);
-        // Destination: if input ends with .enc, strip it; otherwise overwrite the provided path
-        const destPath = fullPath.endsWith('.enc') ? fullPath.slice(0, -4) : fullPath;
+        const destPath = targetPath.endsWith('.enc') ? targetPath.slice(0, -4) : targetPath;
         atomicWrite(destPath, decrypted);
-        console.log(`Successfully decrypted ${path.basename(fullPath)} -> ${path.basename(destPath)}`);
+        console.log(`Successfully decrypted ${path.basename(targetPath)} -> ${path.basename(destPath)}`);
+    }
+    else if (command === 'postbuild' || command === 'post-build' || command === 'inject') {
+        decryptPostBuild();
     }
     else {
         console.error(`Unknown command: ${command}`);

package/dist/scripts/config-vault.ts

@@ -15,35 +15,22 @@ import { encrypt, decrypt, isEncrypted } from '../components/config/crypto';
  */
 
 const [,, command, targetPath, argKey] = process.argv;
-let key = argKey || process.env.PIXELATED_CONFIG_KEY;
 
-// If key is still missing, try to load it from .env.local
+// Helper: obtain key from arg or env or .env.local (only used for encrypt/decrypt)
+let key = argKey || process.env.PIXELATED_CONFIG_KEY;
 if (!key) {
 	const envPath = path.join(process.cwd(), '.env.local');
 	if (fs.existsSync(envPath)) {
-		const envContent = fs.readFileSync(envPath, 'utf8');
-		const match = envContent.match(/^PIXELATED_CONFIG_KEY=(.*)$/m);
-		if (match && match[1]) {
-			key = match[1].trim();
+		try {
+			const envContent = fs.readFileSync(envPath, 'utf8');
+			const match = envContent.match(/^PIXELATED_CONFIG_KEY=(.*)$/m);
+			if (match && match[1]) key = match[1].trim();
+		} catch (e) {
+			// ignore
 		}
 	}
 }
 
-if (!command || !targetPath || !key) {
-	console.log('Usage:');
-	console.log('  encrypt <filePath> [key] - Encrypts the file and writes `<filePath>.enc`');
-	console.log('  decrypt <filePath> [key] - Decrypts the file and writes the plaintext file (atomic write)');
-	console.log('\nNote: Key can be passed as argument or via PIXELATED_CONFIG_KEY env var.');
-	process.exit(1);
-}
-
-const fullPath = path.isAbsolute(targetPath) ? targetPath : path.resolve(process.cwd(), targetPath);
-
-if (!fs.existsSync(fullPath)) {
-	console.error(`File not found: ${fullPath}`);
-	process.exit(1);
-}
-
 const atomicWrite = (destPath: string, data: string) => {
 	const dir = path.dirname(destPath);
 	const base = path.basename(destPath);
@@ -52,28 +39,150 @@ const atomicWrite = (destPath: string, data: string) => {
 	fs.renameSync(tmp, destPath);
 };
 
+// Helper: print usage/help
+function printUsage(): void {
+	console.log('Usage:');
+	console.log('  npx tsx src/scripts/config-vault.ts encrypt <filePath> [key]   - Encrypts <filePath> (writes <filePath>.enc)');
+	console.log('  npx tsx src/scripts/config-vault.ts decrypt <filePath> [key]   - Decrypts <filePath>.enc and writes plaintext');
+	console.log('  npx tsx src/scripts/config-vault.ts postbuild                  - CI helper: decrypts and injects into .next/server');
+	console.log('\nNotes:');
+	console.log('  - Key can be passed as argument or via PIXELATED_CONFIG_KEY env var.');
+	console.log('  - Use PIXELATED_CONFIG_DEBUG=1 for verbose output during postbuild.');
+}
+
+// Helpful messages when arguments are missing
+if (!command) {
+	console.log('No command provided.');
+	printUsage();
+	process.exit(0);
+}
+if (command === 'help' || command === '--help' || command === '-h') {
+	printUsage();
+	process.exit(0);
+}
+
+// If encrypt/decrypt are requested, ensure targetPath and key exist; log informative messages
+if (command === 'encrypt' || command === 'decrypt') {
+	if (!targetPath) {
+		console.log('No target path provided for encrypt/decrypt.');
+		printUsage();
+		process.exit(1);
+	}
+	if (!key) {
+		// we attempted to resolve key from env/.env.local earlier; if still missing, inform the user
+		console.log('No key provided for encrypt/decrypt (argument, PIXELATED_CONFIG_KEY, or .env.local).');
+		printUsage();
+		process.exit(1);
+	}
+}
+
+/**
+ * Post-build behavior used by CI (Amplify):
+ * - Look for an encrypted config file in standard candidate locations
+ * - Validate PIXELATED_CONFIG_KEY (from env or .env.local)
+ * - Decrypt in-place and copy plaintext to .next/server/pixelated.config.json
+ * - Validate JSON and emit a concise success message
+ */
+function decryptPostBuild(): void {
+	const DEBUG = process.env.PIXELATED_CONFIG_DEBUG === '1';
+	const candidates = [
+		path.join(process.cwd(), 'src/app/config/pixelated.config.json.enc'),
+		path.join(process.cwd(), 'src/config/pixelated.config.json.enc'),
+		path.join(process.cwd(), 'src/pixelated.config.json.enc'),
+	];
+
+	let foundEnc: string | null = null;
+	for (const p of candidates) {
+		if (fs.existsSync(p)) {
+			foundEnc = p;
+			break;
+		}
+	}
+
+	if (!foundEnc) {
+		if (DEBUG) console.log('No encrypted config found; nothing to do.');
+		process.exit(0);
+	}
+
+	// Resolve key (env preferred, then .env.local)
+	let keyLocal = process.env.PIXELATED_CONFIG_KEY;
+	if (!keyLocal) {
+		const envPath = path.join(process.cwd(), '.env.local');
+		if (fs.existsSync(envPath)) {
+			try {
+				const envContent = fs.readFileSync(envPath, 'utf8');
+				const match = envContent.match(/^PIXELATED_CONFIG_KEY=(.*)$/m);
+				if (match && match[1]) keyLocal = match[1].trim();
+			} catch (e) {
+				// ignore
+			}
+		}
+	}
+
+	if (!keyLocal) {
+		console.error('PIXELATED_CONFIG_KEY not set; cannot decrypt config.');
+		process.exit(1);
+	}
+	if (!/^[0-9a-fA-F]{64}$/.test(keyLocal)) {
+		console.error('PIXELATED_CONFIG_KEY invalid: must be 64 hex characters.');
+		process.exit(1);
+	}
+
+	try {
+		const raw = fs.readFileSync(foundEnc, 'utf8');
+		if (!isEncrypted(raw)) {
+			console.error('Found file is not in encrypted format.');
+			process.exit(1);
+		}
+		const decrypted = decrypt(raw, keyLocal);
+		const dest = foundEnc.endsWith('.enc') ? foundEnc.slice(0, -4) : `${foundEnc}.plain`;
+		atomicWrite(dest, decrypted);
+		// Copy to .next/server for SSR to pick up
+		const injectPath = path.join(process.cwd(), '.next', 'server', 'pixelated.config.json');
+		fs.mkdirSync(path.dirname(injectPath), { recursive: true });
+		fs.copyFileSync(dest, injectPath);
+		// Validate JSON
+		JSON.parse(decrypted);
+		console.log('Config injected into .next/server/pixelated.config.json');
+		if (DEBUG) console.log(`Decrypted ${path.basename(foundEnc)} -> ${injectPath}`);
+		process.exit(0);
+	} catch (err: any) {
+		console.error(`Post-build decrypt failed: ${err.message}`);
+		process.exit(1);
+	}
+}
+
 try {
 	if (command === 'encrypt') {
-		const content = fs.readFileSync(fullPath, 'utf8');
+		if (!key) {
+			console.error('Encryption key is required.');
+			process.exit(1);
+		}
+		const content = fs.readFileSync(targetPath, 'utf8');
 		if (isEncrypted(content)) {
 			console.log('File is already encrypted. No action taken.');
 			process.exit(0);
 		}
 		const encrypted = encrypt(content, key);
-		const encPath = fullPath.endsWith('.enc') ? fullPath : `${fullPath}.enc`;
+		const encPath = targetPath.endsWith('.enc') ? targetPath : `${targetPath}.enc`;
 		atomicWrite(encPath, encrypted);
 		console.log(`Successfully encrypted ${targetPath} -> ${path.basename(encPath)}`);
 	} else if (command === 'decrypt') {
-		const content = fs.readFileSync(fullPath, 'utf8');
+		if (!key) {
+			console.error('Decryption key is required.');
+			process.exit(1);
+		}
+		const content = fs.readFileSync(targetPath, 'utf8');
 		if (!isEncrypted(content)) {
 			console.log('File is not encrypted. No action taken.');
 			process.exit(0);
 		}
 		const decrypted = decrypt(content, key);
-		// Destination: if input ends with .enc, strip it; otherwise overwrite the provided path
-		const destPath = fullPath.endsWith('.enc') ? fullPath.slice(0, -4) : fullPath;
+		const destPath = targetPath.endsWith('.enc') ? targetPath.slice(0, -4) : targetPath;
 		atomicWrite(destPath, decrypted);
-		console.log(`Successfully decrypted ${path.basename(fullPath)} -> ${path.basename(destPath)}`);
+		console.log(`Successfully decrypted ${path.basename(targetPath)} -> ${path.basename(destPath)}`);
+	} else if (command === 'postbuild' || command === 'post-build' || command === 'inject') {
+		decryptPostBuild();
 	} else {
 		console.error(`Unknown command: ${command}`);
 		process.exit(1);

package/dist/scripts/create-pixelated-app.js

@@ -79,6 +79,8 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 const exec = promisify(execCb);
+// Exportable exec wrapper so tests can stub it.
+export let _exec = exec;
 
 async function exists(p) {
 	try {
@@ -232,6 +234,112 @@ export async function copyTemplateForPage(templatePathArg, templateSrc, template
 }
 
 
+export async function createAndPushRemote(destPath, siteName, defaultOwner) {
+	// Initialize a local git repo and make the initial commit
+	await _exec('git init -b main', { cwd: destPath });
+	await _exec('git add .', { cwd: destPath });
+	await _exec('git commit -m "chore: initial commit from pixelated-template"', { cwd: destPath });
+	console.log('✅ Git initialized and initial commit created.');
+
+	// If an encrypted config exists, attempt a non-fatal decrypt in the new site to ensure the token can be read
+	const encCandidates = [
+		path.join(destPath, 'src', 'app', 'config', 'pixelated.config.json.enc'),
+		path.join(destPath, 'src', 'config', 'pixelated.config.json.enc'),
+		path.join(destPath, 'src', 'pixelated.config.json.enc'),
+		path.join(destPath, 'pixelated.config.json.enc'),
+		path.join(destPath, 'dist', 'config', 'pixelated.config.json.enc')
+	];
+	for (const p of encCandidates) {
+		if (await exists(p)) {
+			console.log(`Found encrypted config at ${p}. Attempting to run 'npm run config:decrypt' in the new site (non-fatal)`);
+			try {
+				await _exec('npm run config:decrypt', { cwd: destPath, timeout: 60_000 });
+				console.log('Attempted config:decrypt (non-fatal)');
+			} catch (err) {
+				console.warn('config:decrypt failed or PIXELATED_CONFIG_KEY missing (non-fatal):', err?.message || err);
+			}
+			break;
+		}
+	}
+
+	// Create a small temporary script inside the new site to reliably import the project's provider and print JSON to stdout
+	const tmpDir = path.join(destPath, '.px-scripts');
+	const tmpFile = path.join(tmpDir, 'get_github_token.ts');
+	await fs.mkdir(tmpDir, { recursive: true });
+	const tmpContent = `import('./src/components/config/config').then(m => {
+		const cfg = m.getFullPixelatedConfig();
+		// Only print the github object (or null) as JSON to stdout
+		console.log(JSON.stringify(cfg?.github || null));
+	}).catch(e => {
+		console.error('ERR_IMPORT', e?.message || e);
+		process.exit(2);
+	});`;
+	await fs.writeFile(tmpFile, tmpContent, 'utf8');
+
+	let execOut = null;
+	try {
+		execOut = await _exec(`npx tsx ${tmpFile}`, { cwd: destPath, timeout: 60_000 });
+	} catch (e) {
+		// Provide a helpful error message and ensure cleanup happens below
+		console.error('❌ Failed to run config provider to obtain GitHub token. Ensure PIXELATED_CONFIG_KEY is available (e.g., in .env.local) and the site includes an encrypted pixelated.config.json.enc');
+		throw e;
+	} finally {
+		// Always clean up the temporary script directory
+		try { await fs.rm(tmpDir, { recursive: true, force: true }); } catch (_) { /* ignore cleanup errors */ }
+	}
+
+	const outStr = (execOut && execOut.stdout) ? String(execOut.stdout).trim() : '';
+	if (!outStr) {
+		console.error('❌ No output from config provider; cannot locate github token');
+		throw new Error('Missing provider output');
+	}
+
+	let githubInfo = null;
+	try { githubInfo = JSON.parse(outStr); } catch (e) { console.error('❌ Invalid JSON from config provider:', outStr); throw e; }
+	const token = githubInfo?.token;
+	const cfgOwner = githubInfo?.defaultOwner;
+	if (!token) {
+		console.error('❌ github.token not found in decrypted config; cannot create remote repo.');
+		throw new Error('Missing github.token');
+	}
+
+	const repoName = siteName;
+	const ownerForMessage = cfgOwner || defaultOwner;
+	console.log(`Creating GitHub repo: ${ownerForMessage}/${repoName} ...`);
+
+	let resp;
+	try {
+		resp = await fetch('https://api.github.com/user/repos', {
+			method: 'POST',
+			headers: {
+				'Authorization': `token ${token}`,
+				'Content-Type': 'application/json',
+				'User-Agent': 'create-pixelated-app'
+			},
+			body: JSON.stringify({ name: repoName, private: false })
+		});
+	} catch (e) {
+		console.error('❌ Failed to call GitHub API', e?.message || e);
+		throw e;
+	}
+
+	const body = await (async () => { try { return await resp.json(); } catch (e) { return null; } })();
+	if (!resp.ok) {
+		console.error(`❌ Failed to create GitHub repo: ${resp.status} ${resp.statusText} ${body?.message || ''}`);
+		throw new Error('GitHub repo creation failed');
+	}
+	const cloneUrl = body.clone_url;
+	if (!cloneUrl) {
+		console.error('❌ GitHub returned unexpected response (no clone_url)');
+		throw new Error('Invalid GitHub response');
+	}
+
+	// Add remote and push
+	await _exec(`git remote add origin ${cloneUrl}`, { cwd: destPath });
+	await _exec('git branch --show-current || git branch -M main', { cwd: destPath });
+	await _exec('git push -u origin main', { cwd: destPath });
+	console.log(`✅ Remote created and initial commit pushed: ${cloneUrl}`);
+}
 async function main() {
 	const rl = readline.createInterface({ input, output });
 	try {
@@ -435,16 +543,25 @@ async function main() {
 				console.warn('⚠️ Failed to replace placeholders in site copy:', e?.message || e);
 			}
 		}
-		// Prompt about git initialization
-		const initGitAnswer = (await rl.question('Initialize a fresh git repository here? (Y/n): ')) || 'y';
-		if (initGitAnswer.toLowerCase() === 'y' || initGitAnswer.toLowerCase() === 'yes') {
+		// Prompt about creating a new GitHub repository. Default owner is read from components config `github.defaultOwner` (fallback: 'brianwhaley')
+		const componentsCfgPath = path.resolve(__dirname, '..', 'config', 'pixelated.config.json');
+		let defaultOwner = 'brianwhaley';
+		try {
+			if (await exists(componentsCfgPath)) {
+				const compCfgText = await fs.readFile(componentsCfgPath, 'utf8');
+				const compCfg = JSON.parse(compCfgText);
+				if (compCfg?.github?.defaultOwner) defaultOwner = compCfg.github.defaultOwner;
+			}
+		} catch (e) {
+			// ignore and use fallback
+		}
+		const createRemoteAnswer = (await rl.question(`Create a new GitHub repository in '${defaultOwner}' and push the initial commit? (Y/n): `)) || 'y';
+		if (createRemoteAnswer.toLowerCase() === 'y' || createRemoteAnswer.toLowerCase() === 'yes') {
 			try {
-				await exec('git init -b main', { cwd: destPath });
-				await exec('git add .', { cwd: destPath });
-				await exec('git commit -m "chore: initial commit from pixelated-template"', { cwd: destPath });
-				console.log('✅ Git initialized and initial commit created.');
+				await createAndPushRemote(destPath, siteName, defaultOwner);
 			} catch (e) {
-				console.warn('⚠️  Git init or commit failed. You can initialize manually later.', e?.stderr || e?.message || e);
+				console.warn('⚠️  Repo creation or git push failed. Your local repository is still available at:', destPath);
+				console.warn(e?.stderr || e?.message || e);
 			}
 		}
 
@@ -469,3 +586,4 @@ if (typeof process !== 'undefined' && new URL(import.meta.url).pathname === proc
 	// CLI entry point: run the interactive main flow
 	main();
 }
+

package/dist/scripts/create-pixelated-app.js.bak

@@ -0,0 +1,590 @@
+#!/usr/bin/env node
+/**
+ * create-pixelated-app.js
+ *
+ * Simple CLI to scaffold a new site from `pixelated-template`.
+ * - copies the template to a destination folder
+ * - clears out the .git history in the copy
+ * - optionally initializes a fresh git repo and adds a remote
+ *
+ * TODOs (placeholders for later work):
+ *  - Create/patch pixelated.config.json and optionally run config:encrypt
+ *  - Run `npm ci` / `npm run lint` / `npm test` and optionally build
+ *  - Optionally create GitHub repo using API (with token from secure vault)
+ * 
+ * 
+1) Recommended approach (short) ✅
+Build a small Node-based CLI (easier cross-platform than a Bash script) called e.g. scripts/new-site.js or an npm create script.
+Make it interactive with sensible CLI flags (--name, --domain, --repo, --git, --encrypt, --no-install) and a non-interactive mode for CI.
+
+2) High-level workflow the script should perform 🔁
+Validate inputs (target path, site slug, repo name).
+Copy pixelated-template → ./<new-site-name> (preserve file modes).
+Replace placeholders in files (template tokens like {{SITE_NAME}}, {{PACKAGE_NAME}}, {{DOMAIN}}).
+Patch template-specific files (see list below).
+Remove template git metadata (rm -rf .git) and reset any CI state.
+Create/patch pixelated.config.json with site-specific values (ask for secrets). Optionally run npm run config:encrypt to write .enc.
+Run validation: npm ci (optional), npm run lint, npm test, npm run build.
+Init git, make initial commit, optionally create remote GitHub repo (if token available) and push.
+Print summary and next steps (e.g., configure hosting / DNS / deploy keys).
+
+3) Files / fields to update in the template 🔧
+package.json — name, description, repository, author, homepage, version, scripts (if you want to change default scripts).
+README.md — project title and quick-start instructions.
+next.config.ts / amplify.yml — site-specific env entries and build steps.
+pixelated.config.json — update global/aws/contentful/google fields for this site (prefer *.enc workflow).
+src/app/(pages)/… and any site metadata files (site slug, default pagesDir).
+public/ assets and site-images.json — update site logos/URLs.
+certificates/ if using TLS — template may include placeholder paths.
+FEATURE_CHECKLIST.md — optionally update default checklist for new site.
+.gitignore — ensure pixelated.config.json is ignored if plaintext during setup.
+
+4) Template hardening (recommended changes in pixelated-template) ⚠️
+Add placeholder tokens for the things above (e.g., {{PACKAGE_NAME}}, {{SITE_DOMAIN}}) rather than literal values.
+Add a template.json or template.meta that lists files & placeholders to auto-replace.
+Ensure the template does not include real secrets. Provide pixelated.config.json.example with placeholders and an example .env.local.example.
+Add a scripts/prepare-template.sh or test job that ensures no plaintext sensitive values remain.
+Document the creation process in TEMPLATE_README.md for maintainers.
+
+5) Security & operational notes 🔐
+Do not commit plaintext pixelated.config.json. If the CLI accepts secret values, optionally run npm run config:encrypt immediately and only commit the .enc if needed (prefer not to commit it; store in site secrets store).
+Add an option to write the encrypted file directly into dist/config when building a deployment bundle.
+Provide an audit step: scan resulting repo for secret patterns before final commit/push.
+
+6) Helpful CLI implementation details (tools & libs) 🛠️
+Use Node + these packages: fs-extra (copy), replace-in-file or simple .replace() for template tokens, inquirer (prompt), execa (run commands), simple-git (git ops), node-fetch or @octokit/rest (optional GitHub repo creation).
+Use safe file writes and atomic renames for config operations.
+Provide a --dry-run and --preview mode so users can verify changes before creating repo or pushing.
+
+7) Validation & post-creation steps ✅
+npm run lint && npm test && npm run build — fail fast and show errors for the new site.
+Optional: run npm run config:decrypt locally (with provided key) to confirm decryption works in your deploy workflow (BUT DO NOT store the key in the repo).
+
+8) Example minimal CLI flow (pseudo)
+Prompt: site name, package name, repo URL (optional), domain, author, contentful tokens, aws keys (optional), encrypt?
+Copy template → replace tokens → create pixelated.config.json from pixelated.config.json.example → encrypt if requested → init git → run install/build → push to remote.
+
+*/
+
+import fs from 'fs/promises';
+import path from 'path';
+import { exec as execCb } from 'child_process';
+import { promisify } from 'util';
+import readline from 'readline/promises';
+import { stdin as input, stdout as output } from 'process';
+import { fileURLToPath } from 'url';
+import { loadManifest, findTemplateForSlug, pruneTemplateDirs, printAvailableTemplates } from './create-pixelated-app-template-mapper.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const exec = promisify(execCb);
+// Exportable exec wrapper so tests can stub it.
+export let _exec = exec;
+
+async function exists(p) {
+	try {
+		await fs.access(p);
+		return true;
+	} catch (e) {
+		return false;
+	}
+}
+
+async function countFiles(src) {
+	let total = 0;
+	async function walk(p) {
+		const stat = await fs.lstat(p);
+		if (stat.isDirectory()) {
+			const items = await fs.readdir(p, { withFileTypes: true });
+			for (const item of items) {
+				await walk(path.join(p, item.name));
+			}
+		} else {
+			total++;
+		}
+	}
+	await walk(src);
+	return total;
+}
+
+function startSpinner(messageFn) {
+	if (!process.stdout.isTTY) return { stop: () => {} };
+	const frames = ['-', '\\', '|', '/'];
+	let i = 0;
+	const interval = setInterval(() => {
+		const msg = messageFn ? messageFn() : '';
+		process.stdout.write(`\r${frames[i % frames.length]} ${msg}`);
+		i++;
+	}, 100);
+	return {
+		stop: () => {
+			clearInterval(interval);
+			process.stdout.write('\r');
+			process.stdout.write('\n');
+		}
+	};
+}
+
+async function copyRecursive(src, dest, onFileCopied) {
+	// Recursive copy that reports per-file progress via onFileCopied.
+	await fs.mkdir(dest, { recursive: true });
+	const items = await fs.readdir(src, { withFileTypes: true });
+	for (const item of items) {
+		const s = path.join(src, item.name);
+		const d = path.join(dest, item.name);
+		const stat = await fs.lstat(s);
+		if (stat.isDirectory()) {
+			await copyRecursive(s, d, onFileCopied);
+		} else if (stat.isSymbolicLink()) {
+			try {
+				const link = await fs.readlink(s);
+				await fs.symlink(link, d);
+				if (onFileCopied) onFileCopied(d);
+			} catch (e) {
+				// ignore symlink failures
+				if (onFileCopied) onFileCopied(d);
+			}
+		} else {
+			// Regular file
+			await fs.copyFile(s, d);
+			if (onFileCopied) onFileCopied(d);
+		}
+	}
+}
+
+// Replace placeholders like {{SITE_NAME}}, {{SITE_URL}}, {{EMAIL_ADDRESS}} across the created site
+// This supports both literal tags and simple regex patterns (for cases where the bundler
+// transformed template tokens into JS expressions like {SITE_NAME}). Each replacement
+// entry may have { tag, value, isRegex } where isRegex indicates `tag` is a regex string.
+async function replacePlaceholders(rootDir, replacements) {
+	const ignoreDirs = new Set(['.git', 'node_modules', 'dist', 'coverage']);
+	let filesChanged = 0;
+	async function walk(p) {
+		const items = await fs.readdir(p, { withFileTypes: true });
+		for (const item of items) {
+			const entry = path.join(p, item.name);
+			if (item.isDirectory()) {
+				// Allow running against .next when explicitly targeting it, but skip when walking a template
+				if (item.name === '.next' && rootDir !== '.next') continue;
+				if (ignoreDirs.has(item.name)) continue;
+				await walk(entry);
+			} else {
+				try {
+					let content = await fs.readFile(entry, 'utf8');
+					let newContent = content;
+					for (const { tag, value, isRegex } of replacements) {
+						let re;
+						if (isRegex) {
+							re = new RegExp(tag, 'g');
+						} else {
+							re = new RegExp(tag.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g');
+						}
+						newContent = newContent.replace(re, value);
+					}
+					if (newContent !== content) {
+						await fs.writeFile(entry, newContent, 'utf8');
+						filesChanged++;
+					}
+				} catch (e) {
+					// Could be binary or unreadable - skip
+				}
+			}
+		}
+	}
+	await walk(rootDir);
+	return filesChanged;
+}
+
+// Token map used by the CLI: literal marker (e.g., "__SITE_NAME__") -> replacement value (populate during interactive prompts)
+export const TOKEN_MAP = { 
+	"__SITE_NAME__": '', 
+	"__SITE_URL__": '', 
+	"__EMAIL_ADDRESS__": '' 
+};
+
+// Helper: add a route entry to the routes.json structure for a newly created page
+export function addRouteEntry(routesJson, pageSlug, displayName, rootDisplayName) {
+	if (!routesJson || !Array.isArray(routesJson.routes)) return false;
+	const candidatePath = `/${pageSlug}`;
+	if (routesJson.routes.some(r => r.path === candidatePath)) return false;
+	const name = displayName.split(/\s+/).map(s => s.charAt(0).toUpperCase() + s.slice(1)).join(' ');
+	routesJson.routes.push({
+		"name": name,
+		"path": candidatePath,
+		"title": `${rootDisplayName} - ${displayName}`,
+		"description": "",
+		"keywords": ""
+	});
+	return true;
+}
+
+// Copy a template page into the target directory, resolving to the expected location inside the workspace template.
+// Returns an object { used: 'template'|'fallback', src: <sourcePath> }
+export async function copyTemplateForPage(templatePathArg, templateSrc, templatePagesHome, targetDir) {
+	const folderName = path.basename(templateSrc);
+	const srcTemplatePath = path.join(templatePathArg, 'src', 'app', '(pages)', folderName);
+	if (await exists(srcTemplatePath)) {
+		await copyRecursive(srcTemplatePath, targetDir);
+		return { used: 'template', src: srcTemplatePath };
+	} else {
+		await copyRecursive(templatePagesHome, targetDir);
+		return { used: 'fallback', src: templatePagesHome };
+	}
+}
+
+
+export async function createAndPushRemote(destPath, siteName, defaultOwner) {
+	// Initialize a local git repo and make the initial commit
+	await _exec('git init -b main', { cwd: destPath });
+	await _exec('git add .', { cwd: destPath });
+	await _exec('git commit -m "chore: initial commit from pixelated-template"', { cwd: destPath });
+	console.log('✅ Git initialized and initial commit created.');
+
+	// If an encrypted config exists, attempt a non-fatal decrypt in the new site to ensure the token can be read
+	const encCandidates = [
+		path.join(destPath, 'src', 'app', 'config', 'pixelated.config.json.enc'),
+		path.join(destPath, 'src', 'config', 'pixelated.config.json.enc'),
+		path.join(destPath, 'src', 'pixelated.config.json.enc'),
+		path.join(destPath, 'pixelated.config.json.enc'),
+		path.join(destPath, 'dist', 'config', 'pixelated.config.json.enc')
+	];
+	for (const p of encCandidates) {
+		if (await exists(p)) {
+			console.log(`Found encrypted config at ${p}. Attempting to run 'npm run config:decrypt' in the new site (non-fatal)`);
+			try {
+				await _exec('npm run config:decrypt', { cwd: destPath, timeout: 60_000 });
+				console.log('Attempted config:decrypt (non-fatal)');
+			} catch (err) {
+				console.warn('config:decrypt failed or PIXELATED_CONFIG_KEY missing (non-fatal):', err?.message || err);
+			}
+			break;
+		}
+	}
+
+	// Create a small temporary script inside the new site to reliably import the project's provider and print JSON to stdout
+	const tmpDir = path.join(destPath, '.px-scripts');
+	const tmpFile = path.join(tmpDir, 'get_github_token.ts');
+	await fs.mkdir(tmpDir, { recursive: true });
+	const tmpContent = `import('./src/components/config/config').then(m => {
+		const cfg = m.getFullPixelatedConfig();
+		// Only print the github object (or null) as JSON to stdout
+		console.log(JSON.stringify(cfg?.github || null));
+	}).catch(e => {
+		console.error('ERR_IMPORT', e?.message || e);
+		process.exit(2);
+	});`;
+	await fs.writeFile(tmpFile, tmpContent, 'utf8');
+
+	let execOut = null;
+	try {
+		execOut = await _exec(`npx tsx ${tmpFile}`, { cwd: destPath, timeout: 60_000 });
+	} catch (e) {
+		// Provide a helpful error message and ensure cleanup happens below
+		console.error('❌ Failed to run config provider to obtain GitHub token. Ensure PIXELATED_CONFIG_KEY is available (e.g., in .env.local) and the site includes an encrypted pixelated.config.json.enc');
+		throw e;
+	} finally {
+		// Always clean up the temporary script directory
+		try { await fs.rm(tmpDir, { recursive: true, force: true }); } catch (_) { /* ignore cleanup errors */ }
+	}
+
+	const outStr = (execOut && execOut.stdout) ? String(execOut.stdout).trim() : '';
+	if (!outStr) {
+		console.error('❌ No output from config provider; cannot locate github token');
+		throw new Error('Missing provider output');
+	}
+
+	let githubInfo = null;
+	try { githubInfo = JSON.parse(outStr); } catch (e) { console.error('❌ Invalid JSON from config provider:', outStr); throw e; }
+	const token = githubInfo?.token;
+	const cfgOwner = githubInfo?.defaultOwner;
+	if (!token) {
+		console.error('❌ github.token not found in decrypted config; cannot create remote repo.');
+		throw new Error('Missing github.token');
+	}
+
+	const repoName = siteName;
+	const ownerForMessage = cfgOwner || defaultOwner;
+	console.log(`Creating GitHub repo: ${ownerForMessage}/${repoName} ...`);
+
+	let resp;
+	try {
+		resp = await fetch('https://api.github.com/user/repos', {
+			method: 'POST',
+			headers: {
+				'Authorization': `token ${token}`,
+				'Content-Type': 'application/json',
+				'User-Agent': 'create-pixelated-app'
+			},
+			body: JSON.stringify({ name: repoName, private: false })
+		});
+	} catch (e) {
+		console.error('❌ Failed to call GitHub API', e?.message || e);
+		throw e;
+	}
+
+	const body = await (async () => { try { return await resp.json(); } catch (e) { return null; } })();
+	if (!resp.ok) {
+		console.error(`❌ Failed to create GitHub repo: ${resp.status} ${resp.statusText} ${body?.message || ''}`);
+		throw new Error('GitHub repo creation failed');
+	}
+	const cloneUrl = body.clone_url;
+	if (!cloneUrl) {
+		console.error('❌ GitHub returned unexpected response (no clone_url)');
+		throw new Error('Invalid GitHub response');
+	}
+
+	// Add remote and push
+	await _exec(`git remote add origin ${cloneUrl}`, { cwd: destPath });
+	await _exec('git branch --show-current || git branch -M main', { cwd: destPath });
+	await _exec('git push -u origin main', { cwd: destPath });
+	console.log(`✅ Remote created and initial commit pushed: ${cloneUrl}`);
+}
+	async function main() {
+		const rl = readline.createInterface({ input, output });
+		try {
+			console.log('\n📦 Pixelated site creator — scaffold a new site from pixelated-template\n');
+
+			const defaultName = 'my-site';
+			const siteName = (await rl.question(`Root directory name (kebab-case) [${defaultName}]: `)) || defaultName;
+
+			// Display name used in route titles: convert kebab to Title Case
+			const rootDisplayName = siteName.split(/[-_]+/).map(s => s.charAt(0).toUpperCase() + s.slice(1)).join(' ');
+
+			// Additional site metadata for placeholder substitution
+			const siteUrl = (await rl.question('Site URL (e.g. https://example.com) [leave blank to skip]: ')).trim();
+			const emailAddress = (await rl.question('Contact email address [leave blank to skip]: ')).trim();
+
+			const workspaceRoot = path.resolve(__dirname, '..', '..', '..');
+			const templatePath = path.resolve(workspaceRoot, 'pixelated-template');
+			if (!(await exists(templatePath))) {
+				console.error(`\n❌ Template not found at ${templatePath}. Please ensure this tool is run inside the workspace that contains pixelated-template.`);
+				process.exit(1);
+			}
+
+			// Load manifest (if present)
+			const manifest = await loadManifest(__dirname);
+			// Note: available templates will be printed later just before prompting for pages
+		
+
+			// Destination is implicitly the top-level Git folder + site name to avoid prompting for it
+			const destPath = path.resolve(workspaceRoot, siteName);
+			console.log(`\nThe new site will be created at: ${destPath}`);
+			const proceed = (await rl.question('Proceed? (Y/n): ')) || 'y';
+			if (proceed.toLowerCase() !== 'y' && proceed.toLowerCase() !== 'yes') {
+				console.log('Aborting.');
+				process.exit(0);
+			} 
+
+			if (await exists(destPath)) {
+				const shouldOverwrite = (await rl.question(`Destination ${destPath} already exists. Overwrite? (y/N): `)).toLowerCase();
+				if (shouldOverwrite !== 'y' && shouldOverwrite !== 'yes') {
+					console.log('Aborting. Choose another destination.');
+					process.exit(0);
+				}
+				console.log(`Removing existing directory ${destPath}...`);
+				await fs.rm(destPath, { recursive: true, force: true });
+			}
+
+			console.log(`\nCopying template from ${templatePath} -> ${destPath} ...`);
+			const totalFiles = await countFiles(templatePath);
+			let filesCopied = 0;
+			let lastFile = '';
+			const spinner = startSpinner(() => `Copying... ${filesCopied}/${totalFiles} ${lastFile ? '- ' + path.basename(lastFile) : ''}`);
+			await copyRecursive(templatePath, destPath, (f) => { if (f) { filesCopied++; lastFile = f; } });
+			// If fs.cp was used, per-file callbacks won't have been called; ensure we report the full total
+			if (filesCopied < totalFiles) filesCopied = totalFiles;
+			spinner.stop();
+			console.log(`✅ Template files copied (${filesCopied} files).`);
+
+			// Remove git history
+			const gitDir = path.join(destPath, '.git');
+			if (await exists(gitDir)) {
+				console.log('Removing .git directory from new site...');
+				await fs.rm(gitDir, { recursive: true, force: true });
+			}
+
+			// Pages prompt: show available templates and ask which pages to create (comma-separated)
+			if (manifest && Array.isArray(manifest.templates) && manifest.templates.length) {
+				printAvailableTemplates(manifest);
+			}
+			const pagesInput = (await rl.question('Pages to create (comma-separated, e.g. about,contact) [leave blank to skip]: ')).trim();
+			let pagesToCreate = [];
+			let existingPages = [];
+			if (pagesInput) {
+				const raw = pagesInput.split(',').map(s => s.trim()).filter(Boolean);
+				// sanitize and normalize
+				const seen = new Set();
+				for (const r of raw) {
+					const lower = r.toLowerCase();
+					if (lower === 'home' || lower === 'index') {
+						existingPages.push('home');
+						continue;
+					}
+					let slug = r.trim().toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
+					if (!slug) continue;
+					if (seen.has(slug)) continue;
+					seen.add(slug);
+					const matchedTemplate = findTemplateForSlug(manifest, slug);
+					pagesToCreate.push({ slug, displayName: r.trim(), template: matchedTemplate });
+				}
+
+				console.log('\nSummary of pages:');
+				if (existingPages.length) console.log(` - Existing (skipped): ${existingPages.join(', ')}`);
+				if (pagesToCreate.length) {
+					console.log(' - To be created:');
+					for (const p of pagesToCreate) {
+						if (p.template) {
+							console.log(`   - ${p.slug} (mapped to template: ${p.template.name})`);
+						} else {
+							console.log(`   - ${p.slug} (no template match)`);
+						}
+					}
+				}
+				const proceedPages = (await rl.question('Proceed to create these pages? (Y/n): ')) || 'y';
+				if (proceedPages.toLowerCase() === 'y' || proceedPages.toLowerCase() === 'yes') {
+				// perform creation
+					const templatePagesHome = path.join(templatePath, 'src', 'app', '(pages)', '(home)');
+					const siteRoutesFile = path.join(destPath, 'src', 'app', 'data', 'routes.json');
+					let routesJson = null;
+					try {
+						routesJson = JSON.parse(await fs.readFile(siteRoutesFile, 'utf8'));
+						// Ensure siteInfo exists and set its name to the root display name
+						routesJson.siteInfo = routesJson.siteInfo || {};
+						routesJson.siteInfo.name = rootDisplayName;
+					} catch (e) {
+						console.warn('⚠️  Could not read routes.json, routes will not be updated.');
+					}
+
+					for (const p of pagesToCreate) {
+						const targetDir = path.join(destPath, 'src', 'app', '(pages)', p.slug);
+						console.log(`Creating page ${p.slug} -> ${targetDir}`);
+						let copyResult = null;
+						if (p.template && p.template.src) {
+							copyResult = await copyTemplateForPage(templatePath, p.template.src, templatePagesHome, targetDir);
+							if (copyResult.used === 'template') {
+								console.log(` - Copied template ${p.template.name} from ${copyResult.src}`);
+							} else {
+								console.warn(`⚠️  Template source ${path.join(templatePath, 'src', 'app', '(pages)', path.basename(p.template.src))} not found; using default page template instead.`);
+							}
+						} else {
+							await copyRecursive(templatePagesHome, targetDir);
+						}
+						// rename component in page.tsx
+						const pageFile = path.join(targetDir, 'page.tsx');
+						try {
+							let content = await fs.readFile(pageFile, 'utf8');
+							const compName = p.displayName.replace(/[^a-zA-Z0-9]+/g,' ').split(/\s+/).map(s=>s.charAt(0).toUpperCase()+s.slice(1)).join('') + 'Page';
+							content = content.replace(/export default function\s+\w+\s*\(/, `export default function ${compName}(`);
+							await fs.writeFile(pageFile, content, 'utf8');
+							console.log(` - Updated component name to ${compName} in ${path.relative(destPath, pageFile)}`);
+						} catch (e) {
+							console.warn(`⚠️  Failed to update component name for ${p.slug}:`, e?.message || e);
+						}
+
+						// update routes.json
+						if (routesJson && Array.isArray(routesJson.routes)) {
+						// Skip if route path already exists
+							const candidatePath = `/${p.slug}`;
+							if (!routesJson.routes.some(r => r.path === candidatePath)) {
+								routesJson.routes.push({
+									"name": p.displayName.split(/\s+/).map(s=>s.charAt(0).toUpperCase()+s.slice(1)).join(' '),
+									"path": candidatePath,
+									"title": `${rootDisplayName} - ${p.displayName}`,
+									"description": "",
+									"keywords": ""
+								});
+							} else {
+								console.log(` - Route ${candidatePath} already exists; skipping route add.`);
+							}
+						}
+					}
+
+					if (manifest) {
+						const removed = await pruneTemplateDirs(manifest, destPath, pagesToCreate.map(p=>p.slug));
+						for (const r of removed) {
+							console.log(`Removed unused template page ${r} from new site...`);
+						}
+					}
+
+					if (routesJson) {
+						try {
+							await fs.writeFile(siteRoutesFile, JSON.stringify(routesJson, null, '\t'), 'utf8');
+							console.log('✅ routes.json updated.');
+						} catch (e) {
+							console.warn('⚠️  Failed to write routes.json:', e?.message || e);
+						}
+					}
+				} else {
+					console.log('Skipping page creation.');
+				}
+			}
+			// Automatically replace double-underscore template placeholders (e.g., __SITE_NAME__) with provided values
+			const replacements = {};
+			if (rootDisplayName) replacements.SITE_NAME = rootDisplayName;
+			if (siteUrl) replacements.SITE_URL = siteUrl;
+			if (emailAddress) replacements.EMAIL_ADDRESS = emailAddress;
+			if (Object.keys(replacements).length) {
+				const replArray = [];
+				for (const [t, valRaw] of Object.entries(replacements)) {
+					const val = String(valRaw);
+					// populate TOKEN_MAP so other code can inspect token->value mapping (keyed by literal marker)
+					const marker = `__${t}__`;
+					TOKEN_MAP[marker] = val;
+					// First, replace expression occurrences like {__TOKEN__} with a quoted string expression to avoid bare identifiers
+					replArray.push({ tag: `\\{${marker}\\}`, value: `{${JSON.stringify(val)}}`, isRegex: true });
+					// Then, replace literal marker occurrences (e.g., __TOKEN__) with the plain value
+					replArray.push({ tag: marker, value: val });
+				}
+				try {
+					const changed = await replacePlaceholders(destPath, replArray);
+					console.log(`✅ Replaced template placeholders in ${changed} files under ${destPath}`);
+				} catch (e) {
+					console.warn('⚠️ Failed to replace placeholders in site copy:', e?.message || e);
+				}
+			}
+			// Prompt about creating a new GitHub repository. Default owner is read from components config `github.defaultOwner` (fallback: 'brianwhaley')
+			const componentsCfgPath = path.resolve(__dirname, '..', 'config', 'pixelated.config.json');
+			let defaultOwner = 'brianwhaley';
+			try {
+				if (await exists(componentsCfgPath)) {
+					const compCfgText = await fs.readFile(componentsCfgPath, 'utf8');
+					const compCfg = JSON.parse(compCfgText);
+					if (compCfg?.github?.defaultOwner) defaultOwner = compCfg.github.defaultOwner;
+				}
+			} catch (e) {
+			// ignore and use fallback
+			}
+			const createRemoteAnswer = (await rl.question(`Create a new GitHub repository in '${defaultOwner}' and push the initial commit? (Y/n): `)) || 'y';
+			if (createRemoteAnswer.toLowerCase() === 'y' || createRemoteAnswer.toLowerCase() === 'yes') {
+				try {
+					await createAndPushRemote(destPath, siteName, defaultOwner);
+				} catch (e) {
+					console.warn('⚠️  Repo creation or git push failed. Your local repository is still available at:', destPath);
+					console.warn(e?.stderr || e?.message || e);
+				}
+			}
+
+
+
+			console.log('\n🎉 Done. Summary:');
+			console.log(` - Site copied to: ${destPath}`);
+			console.log('\nNote: A git remote was not set by this script. You can add one later with `git remote add origin <url>` if desired.');
+			console.log('\nNext recommended steps (manual or to be automated in future):');
+			console.log(' - Update pixelated.config.json for this site and encrypt it with your config tool');
+			console.log(' - Run `npm run lint`, `npm test`, and `npm run build` inside the new site and fix any issues');
+			console.log(' - Create GitHub repo (if not already created), push main branch, and set up CI/deploy secrets');
+		} catch (err) {
+			console.error('Unexpected error:', err);
+			process.exit(1);
+		} finally {
+			rl.close();
+		}
+	}
+
+	if (typeof process !== 'undefined' && new URL(import.meta.url).pathname === process.argv[1]) {
+	// CLI entry point: run the interactive main flow
+		main();
+	}
+
+}

package/dist/types/components/config/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../src/components/config/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,gBAAgB,CAAC;AAO1E;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,eAAe,CA0DxD;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,eAAe,CAIpF"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../src/components/config/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,gBAAgB,CAAC;AAO1E;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,eAAe,CA4FxD;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,eAAe,CAIpF"}

package/dist/types/scripts/create-pixelated-app.d.ts

@@ -4,9 +4,12 @@ export function copyTemplateForPage(templatePathArg: any, templateSrc: any, temp
     used: string;
     src: any;
 }>;
+export function createAndPushRemote(destPath: any, siteName: any, defaultOwner: any): Promise<void>;
+export let _exec: typeof execCb.__promisify__;
 export namespace TOKEN_MAP {
     let __SITE_NAME__: string;
     let __SITE_URL__: string;
     let __EMAIL_ADDRESS__: string;
 }
+import { exec as execCb } from 'child_process';
 //# sourceMappingURL=create-pixelated-app.d.ts.map

package/dist/types/scripts/create-pixelated-app.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-pixelated-app.d.ts","sourceRoot":"","sources":["../../../src/scripts/create-pixelated-app.js"],"names":[],"mappings":";AA4MA,+GAaC;AAID;;;GAUC"}
+{"version":3,"file":"create-pixelated-app.d.ts","sourceRoot":"","sources":["../../../src/scripts/create-pixelated-app.js"],"names":[],"mappings":";AA8MA,+GAaC;AAID;;;GAUC;AAGD,oGAyGC;AAnQD,8CAAwB;;;;;;+BAZO,eAAe"}

package/dist/types/tests/create-pixelated-app.github.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=create-pixelated-app.github.test.d.ts.map

package/dist/types/tests/create-pixelated-app.github.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-pixelated-app.github.test.d.ts","sourceRoot":"","sources":["../../../src/tests/create-pixelated-app.github.test.js"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pixelated-tech/components",
-	"version": "3.9.14",
+	"version": "3.9.16",
 	"private": false,
 	"author": {
 		"name": "Pixelated Technologies",
@@ -82,7 +82,7 @@
 		"vault": "npx tsx src/scripts/config-vault.ts",
 		"config:vault": "npm run vault --",
 		"config:encrypt": "npm run config:vault -- encrypt src/config/pixelated.config.json",
-		"config:decrypt": "npm run config:vault -- decrypt src/config/pixelated.config.json",
+		"config:decrypt": "npm run config:vault -- decrypt src/config/pixelated.config.json.enc",
 		"create-pixelated-app": "node src/scripts/create-pixelated-app.js"
 	},
 	"scripts-20260113": {
@@ -146,11 +146,11 @@
 		"eslint-plugin-react": "^7.37.4",
 		"eslint-plugin-storybook": "^10.1.11",
 		"file-loader": "^6.2.0",
-		"happy-dom": "^20.3.0",
+		"happy-dom": "^20.3.1",
 		"jsdom": "^27.4.0",
 		"less-loader": "^12.3.0",
-		"mini-css-extract-plugin": "^2.9.4",
-		"next": "^16.1.2",
+		"mini-css-extract-plugin": "^2.10.0",
+		"next": "^16.1.3",
 		"null-loader": "^4.0.1",
 		"prop-types": "^15.8.1",
 		"react": "^19.2.3",
@@ -177,9 +177,9 @@
 		"react-dom": "^19.2.0"
 	},
 	"optionalDependencies": {
-		"@aws-sdk/client-cloudwatch": "^3.969.0",
-		"@aws-sdk/client-route-53": "^3.969.0",
-		"googleapis": "^170.0.0",
+		"@aws-sdk/client-cloudwatch": "^3.971.0",
+		"@aws-sdk/client-route-53": "^3.971.0",
+		"googleapis": "^170.1.0",
 		"md5": "^2.3.0",
 		"puppeteer": "^24.35.0",
 		"react-redux": "*",