pixelstart 1.0.0 → 1.2.0

package/dist/index.js

@@ -5,7 +5,7 @@ import { banner, section, success, error, info } from './modules/ui.js';
 import { checkRequirements } from './modules/requirements.js';
 import { showNDA } from './modules/nda.js';
 import { initProject } from './modules/init.js';
-const VERSION = '1.0.0';
+const VERSION = '1.2.0';
 async function main() {
     const args = process.argv.slice(2);
     const command = args[0];
@@ -47,7 +47,7 @@ async function main() {
 async function retryPull() {
     section('Pull Docker Image');
     const inquirer = await import('inquirer');
-    const { validateLicense, exchangeDownloadToken } = await import('./modules/license.js');
+    const { validateLicense, exchangeDownloadToken, buildDockerCommands } = await import('./modules/license.js');
     const { key } = await inquirer.default.prompt([
         {
             type: 'input',
@@ -71,14 +71,18 @@ async function retryPull() {
     info('Pulling Docker image...');
     const { execSync } = await import('child_process');
     try {
-        execSync(downloadResult.dockerCommand, { stdio: 'inherit' });
+        const { login, pull } = buildDockerCommands(downloadResult);
+        execSync(login, { stdio: 'inherit' });
+        execSync(pull, { stdio: 'inherit' });
         console.log('');
         success(`Docker image ${chalk.bold(downloadResult.image)} pulled successfully!`);
     }
     catch {
         error('Docker pull failed. You can retry manually:');
         console.log('');
-        console.log(chalk.white(`  ${downloadResult.dockerCommand}`));
+        const { login, pull } = buildDockerCommands(downloadResult);
+        console.log(chalk.white(`  ${login}`));
+        console.log(chalk.white(`  ${pull}`));
     }
 }
 function printHelp() {

package/dist/modules/init.js

@@ -4,7 +4,7 @@ import path from 'path';
 import inquirer from 'inquirer';
 import chalk from 'chalk';
 import { section, success, error, info } from './ui.js';
-import { validateLicense, exchangeDownloadToken } from './license.js';
+import { validateLicense, exchangeDownloadToken, buildDockerCommands } from './license.js';
 export async function initProject() {
     section('Project Setup');
     const config = await inquirer.prompt([
@@ -103,14 +103,18 @@ data/
         info('Pulling Docker image...');
         console.log('');
         try {
-            execSync(downloadResult.dockerCommand, { stdio: 'inherit' });
+            const { login, pull } = buildDockerCommands(downloadResult);
+            execSync(login, { stdio: 'inherit' });
+            execSync(pull, { stdio: 'inherit' });
             console.log('');
             success(`Docker image ${chalk.bold(downloadResult.image)} pulled successfully!`);
         }
         catch (err) {
             error('Docker pull failed. You can retry manually:');
             console.log('');
-            console.log(chalk.white(`  ${downloadResult.dockerCommand}`));
+            const { login, pull } = buildDockerCommands(downloadResult);
+            console.log(chalk.white(`  ${login}`));
+            console.log(chalk.white(`  ${pull}`));
         }
         console.log('');
         success(`Project "${chalk.bold(config.name)}" created!`);

package/dist/modules/license.d.ts

@@ -7,12 +7,19 @@ export interface LicenseValidation {
 }
 export interface DownloadResult {
     success: boolean;
-    dockerCommand: string;
+    token: string;
     image: string;
+    owner: string;
+    imageName: string;
     tag: string;
+    registry: string;
 }
 export declare function validateLicense(licenseKey: string, imageTag: string): Promise<LicenseValidation | null>;
 export declare function exchangeDownloadToken(token: string): Promise<DownloadResult | null>;
+export declare function buildDockerCommands(result: DownloadResult): {
+    login: string;
+    pull: string;
+};
 export declare function showLicense(): Promise<{
     key: string;
     imageTag: string;

package/dist/modules/license.js

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { section, success, error, info } from './ui.js';
+import { success, error, info, section } from './ui.js';
 const SUPABASE_URL = 'https://qnuzhgozszftvvxsnaos.supabase.co';
 const ANON_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InFudXpoZ296c3pmdHZ2eHNuYW9zIiwicm9sZSI6ImFub24iLCJpYXQiOjE3ODM0MjEwODMsImV4cCI6MjA5ODk5NzA4M30.q3mgpAS8nm1OtvnlKuOgTEi_vLmb46bV0sf3bS-fSCg';
 const EDGE_FUNCTION = `${SUPABASE_URL}/functions/v1/proxy-package`;
@@ -51,6 +51,11 @@ export async function exchangeDownloadToken(token) {
         return null;
     }
 }
+export function buildDockerCommands(result) {
+    const login = `echo ${result.token} | docker login ${result.registry} -u ${result.owner} --password-stdin`;
+    const pull = `docker pull ${result.image}`;
+    return { login, pull };
+}
 export async function showLicense() {
     section('License');
     console.log(chalk.white('  Enter your PixelStack license key to download the image.'));

package/dist/modules/requirements.js

@@ -1,77 +1,232 @@
 import { execSync } from 'child_process';
+import inquirer from 'inquirer';
 import chalk from 'chalk';
 import { success, error, warn, info, section } from './ui.js';
+const P = '#7C3AED';
+const R = '#EF4444';
+const G = '#22C55E';
+const Y = '#EAB308';
+const C = '#06B6D4';
+function c(hex, text) {
+    return String(chalk.hex(hex)(text));
+}
+function cb(hex, text) {
+    return String(chalk.hex(hex).bold(text));
+}
+function getPlatform() {
+    return process.platform;
+}
+function isRoot() {
+    if (getPlatform() === 'win32')
+        return true;
+    try {
+        execSync('id -u', { stdio: 'pipe' });
+        return execSync('id -u', { encoding: 'utf-8', stdio: 'pipe' }).trim() === '0';
+    }
+    catch {
+        return false;
+    }
+}
+function run(cmd, opts = {}) {
+    try {
+        const full = opts.sudo && !isRoot() ? `sudo ${cmd}` : cmd;
+        execSync(full, { stdio: 'pipe', timeout: 120000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function parseVersion(output) {
+    return output.replace(/^[^\d]*/, '').split('+')[0].trim();
+}
+function compareVersions(a, b) {
+    const pa = a.split('.').map(Number);
+    const pb = b.split('.').map(Number);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const na = pa[i] || 0;
+        const nb = pb[i] || 0;
+        if (na > nb)
+            return 1;
+        if (na < nb)
+            return -1;
+    }
+    return 0;
+}
+// ── Install functions per platform ──────────────────────────────────────────
+function getNodeInstallCmd(platform) {
+    switch (platform) {
+        case 'linux':
+            return [
+                'curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -',
+                'sudo apt-get install -y nodejs',
+            ];
+        case 'darwin':
+            return ['brew install node@22'];
+        case 'win32':
+            return ['winget install OpenJS.NodeJS.LTS --accept-package-agreements --accept-source-agreements'];
+    }
+}
+function getDockerInstallCmd(platform) {
+    switch (platform) {
+        case 'linux':
+            return [
+                'curl -fsSL https://get.docker.com | sudo sh',
+                'sudo usermod -aG docker $USER',
+            ];
+        case 'darwin':
+            return ['brew install --cask docker'];
+        case 'win32':
+            return ['winget install Docker.DockerDesktop --accept-package-agreements --accept-source-agreements'];
+    }
+}
+function getPnpmInstallCmd() {
+    return ['npm install -g pnpm@9'];
+}
 const REQUIREMENTS = [
     {
         name: 'Node.js',
         command: 'node --version',
         minVersion: '22.0.0',
         required: true,
-        installHint: 'Install Node.js 22+: https://nodejs.org/',
+        getInstallCmd: getNodeInstallCmd,
+        installHint: 'https://nodejs.org/',
     },
     {
         name: 'Docker',
         command: 'docker --version',
         required: true,
-        installHint: 'Install Docker: https://docs.docker.com/get-docker/',
+        getInstallCmd: getDockerInstallCmd,
+        installHint: 'https://docs.docker.com/get-docker/',
     },
     {
         name: 'Docker Compose',
         command: 'docker compose version',
         required: true,
-        installHint: 'Install Docker Compose: https://docs.docker.com/compose/install/',
+        getInstallCmd: () => [],
+        installHint: 'Included with Docker Desktop',
     },
     {
         name: 'pnpm',
         command: 'pnpm --version',
         minVersion: '9.0.0',
         required: false,
-        installHint: 'Install pnpm: npm install -g pnpm@9',
+        getInstallCmd: getPnpmInstallCmd,
+        installHint: 'npm install -g pnpm@9',
     },
 ];
-function parseVersion(output) {
-    return output.replace(/^[^\d]*/, '').split('+')[0].trim();
-}
-function compareVersions(a, b) {
-    const pa = a.split('.').map(Number);
-    const pb = b.split('.').map(Number);
-    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
-        const na = pa[i] || 0;
-        const nb = pb[i] || 0;
-        if (na > nb)
-            return 1;
-        if (na < nb)
-            return -1;
-    }
-    return 0;
-}
-function checkRequirement(req) {
+function checkRequirement(req, platform) {
     try {
         const output = execSync(req.command, { encoding: 'utf-8', stdio: 'pipe' }).trim();
         const version = parseVersion(output);
         const meetsMin = req.minVersion ? compareVersions(version, req.minVersion) >= 0 : true;
-        return { name: req.name, installed: true, version, meetsMin, required: req.required, minVersion: req.minVersion, installHint: req.installHint };
+        return {
+            name: req.name, installed: true, version, meetsMin,
+            required: req.required, minVersion: req.minVersion,
+            installCmds: req.getInstallCmd(platform), installHint: req.installHint,
+        };
     }
     catch {
-        return { name: req.name, installed: false, required: req.required, installHint: req.installHint };
+        return {
+            name: req.name, installed: false,
+            required: req.required, minVersion: req.minVersion,
+            installCmds: req.getInstallCmd(platform), installHint: req.installHint,
+        };
     }
 }
+async function autoInstall(name, cmds) {
+    console.log('');
+    info(c(C, `Installing ${name}...`));
+    console.log('');
+    for (const cmd of cmds) {
+        console.log(c(P, `  $ ${cmd}`));
+        const sudo = cmd.startsWith('sudo');
+        const ok = run(cmd, { sudo });
+        if (!ok) {
+            error(c(R, `Failed to install ${name}.`));
+            info('You may need to run this command manually or check your internet connection.');
+            return false;
+        }
+    }
+    console.log('');
+    success(c(G, `${name} installed successfully!`));
+    return true;
+}
 export async function checkRequirements() {
     section('System Requirements');
-    const results = REQUIREMENTS.map(checkRequirement);
+    const platform = getPlatform();
+    const platformNames = { linux: 'Linux', darwin: 'macOS', win32: 'Windows' };
+    info(c(C, `Detected platform: ${platformNames[platform]}`));
+    if (!isRoot() && platform !== 'win32') {
+        info(c(Y, 'Some operations may require sudo (password may be prompted)'));
+    }
+    console.log('');
+    const results = REQUIREMENTS.map(r => checkRequirement(r, platform));
     let allPassed = true;
     for (const r of results) {
         if (!r.installed) {
-            error(`${chalk.bold(r.name)} not found`);
-            info(r.installHint);
-            if (r.required)
-                allPassed = false;
+            if (r.installCmds.length > 0) {
+                const { wantInstall } = await inquirer.prompt([{
+                        type: 'confirm',
+                        name: 'wantInstall',
+                        message: cb(R, `  ${r.name} is not installed. Install it now?`),
+                        default: true,
+                    }]);
+                if (wantInstall) {
+                    const ok = await autoInstall(r.name, r.installCmds);
+                    if (!ok) {
+                        if (r.required)
+                            allPassed = false;
+                    }
+                    else {
+                        // Re-check after install
+                        const recheck = checkRequirement(REQUIREMENTS.find(x => x.name === r.name), platform);
+                        if (recheck.installed && recheck.meetsMin !== false) {
+                            success(cb(G, `${r.name} ${recheck.version || ''}`));
+                        }
+                        else if (r.required) {
+                            allPassed = false;
+                        }
+                    }
+                }
+                else {
+                    error(`${chalk.bold(r.name)} is required but not installed.`);
+                    info(r.installHint);
+                    if (r.required)
+                        allPassed = false;
+                }
+            }
+            else {
+                error(`${chalk.bold(r.name)} not found`);
+                info(r.installHint);
+                if (r.required)
+                    allPassed = false;
+            }
         }
         else if (r.meetsMin === false) {
-            warn(`${chalk.bold(r.name)} ${r.version} — requires ${r.minVersion}+`);
-            info(r.installHint);
-            if (r.required)
-                allPassed = false;
+            if (r.installCmds.length > 0) {
+                const { wantUpgrade } = await inquirer.prompt([{
+                        type: 'confirm',
+                        name: 'wantUpgrade',
+                        message: cb(Y, `  ${r.name} ${r.version} is too old (need ${r.minVersion}+). Upgrade?`),
+                        default: true,
+                    }]);
+                if (wantUpgrade) {
+                    const ok = await autoInstall(r.name, r.installCmds);
+                    if (!ok && r.required)
+                        allPassed = false;
+                }
+                else {
+                    if (r.required)
+                        allPassed = false;
+                }
+            }
+            else {
+                warn(`${chalk.bold(r.name)} ${r.version} — requires ${r.minVersion}+`);
+                info(r.installHint);
+                if (r.required)
+                    allPassed = false;
+            }
         }
         else {
             success(`${chalk.bold(r.name)} ${chalk.gray(r.version || '')}`);
@@ -79,7 +234,8 @@ export async function checkRequirements() {
     }
     console.log('');
     if (!allPassed) {
-        error('Missing required dependencies. Please install them and try again.');
+        error('Some required dependencies could not be installed.');
+        info('Please install them manually and try again.');
         return false;
     }
     return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pixelstart",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "PixelStack Lite CLI — scaffold, license, and deploy PixelStack projects",
   "type": "module",
   "main": "dist/index.js",