@iselect/select 1.0.0

package/README.md

@@ -0,0 +1,138 @@
+# Select CLI
+
+Build and deploy apps for web, desktop, and mobile from a single codebase.
+
+```
+   _____ ________    _______________
+  / ___// ____/ /   / ____/ ____/_  /
+  \__ \/ __/ / /   / __/ / /     / / 
+ ___/ / /___/ /___/ /___/ /___  / /  
+/____/_____/_____/_____/\____/ /_/   
+```
+
+## Installation
+
+```bash
+# Option 1: From Source (Recommended for Contributors)
+git clone https://github.com/yourusername/select-cli.git
+cd select-cli
+npm link
+
+# Option 2: From GitHub (If public)
+npm install -g github:yourusername/select-cli
+```
+
+## Quick Start
+
+```bash
+# Create a new project
+slct init my-app
+
+# Navigate to project
+cd my-app
+
+```bash
+# Select target platforms
+slct
+
+# Build for all desktop platforms & web
+slct build all
+
+# Deploy to Select marketplace
+slct deploy
+```
+
+## Commands
+
+### `slct init [name]`
+
+Create a new Select project with interactive prompts.
+
+```bash
+slct init my-app
+slct init --template vue
+```
+
+**Options:**
+- `-t, --template <template>` - Project template (react, vue, vanilla)
+
+### `slct` (or `slct s`)
+
+Interactively select target platforms for your project.
+
+### `slct build [target]`
+
+Build your app for specified platforms.
+
+```bash
+slct build              # Interactive selection
+slct build web          # Build for web only
+slct build desktop      # Build for desktop (Tauri/Electron)
+slct build all          # Build for all platforms (Web + Desktop)
+```
+
+**Options:**
+- `--tauri` - Use Tauri for desktop (default)
+- `--electron` - Use Electron for desktop
+- `--release` - Build for production release
+
+### `slct deploy`
+
+Deploy your app to the Select marketplace.
+
+```bash
+slct deploy
+slct deploy --prod      # Deploy to production
+```
+
+### `slct dev`
+
+Start the development server.
+
+```bash
+slct dev
+slct dev --port 3000
+```
+
+## select.json
+
+Configuration file generated by `slct init`:
+
+```json
+{
+  "name": "my-app",
+  "version": "1.0.0",
+  "description": "A Select app",
+  "platforms": ["web", "windows", "linux"],
+  "desktop": {
+    "framework": "tauri"
+  },
+  "build": {
+    "command": "npm run build",
+    "devCommand": "npm run dev",
+    "outDir": "dist"
+  }
+}
+```
+
+## Platform Requirements
+
+### Tauri (Desktop)
+
+Tauri requires Rust and platform-specific build tools:
+
+1. **Install Rust**: https://rustup.rs/
+2. **Windows**: Install Visual Studio Build Tools
+   - MSVC v143 - VS 2022 C++ x64/x86 build tools
+   - Windows 10/11 SDK
+   - C++ CMake tools
+3. **macOS**: Install Xcode Command Line Tools
+4. **Linux**: Install build-essential and webkit2gtk
+
+### Electron (Desktop)
+
+Electron is automatically installed when selected.
+
+## License
+
+MIT

package/bin/select.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const chalk = require('chalk');
+const pkg = require('../package.json');
+
+// Import commands
+const init = require('../lib/commands/init');
+const select = require('../lib/commands/select');
+const build = require('../lib/commands/build');
+const deploy = require('../lib/commands/deploy');
+const dev = require('../lib/commands/dev');
+
+// ASCII Banner
+console.log(chalk.cyan(`
+   _____ ________    _______________
+  / ___// ____/ /   / ____/ ____/_  /
+  \\__ \\/ __/ / /   / __/ / /     / / 
+ ___/ / /___/ /___/ /___/ /___  / /  
+/____/_____/_____/_____/\\____/ /_/   
+`));
+console.log(chalk.gray(`  v${pkg.version} - Build for web & desktop\n`));
+
+program
+    .name('slct')
+    .description('Build and deploy apps for multiple platforms')
+    .version(pkg.version);
+
+// slct init - Initialize a new project
+program
+    .command('init [name]')
+    .description('Initialize a new Select project')
+    .option('-t, --template <template>', 'Project template (react, vue, vanilla)', 'react')
+    .action(init);
+
+// select - Interactive platform selection
+program
+    .command('select')
+    .alias('s')
+    .description('Interactively select target platforms')
+    .action(select);
+
+// slct build - Build for platforms
+program
+    .command('build [target]')
+    .description('Build for target platform (web, desktop, all)')
+    .option('--tauri', 'Use Tauri for desktop (default)')
+    .option('--electron', 'Use Electron for desktop')
+    .option('--release', 'Build for production release')
+    .action(build);
+
+// slct deploy - Deploy to Select marketplace
+program
+    .command('deploy')
+    .description('Deploy your app to Select marketplace')
+    .option('--prod', 'Deploy to production')
+    .action(deploy);
+
+// slct dev - Start development server
+program
+    .command('dev')
+    .description('Start development server')
+    .option('-p, --port <port>', 'Port number', '5173')
+    .action(dev);
+
+// Parse arguments
+program.parse();

package/lib/commands/build.js

@@ -0,0 +1,405 @@
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const { execSync, spawn } = require('child_process');
+const ora = require('ora');
+const inquirer = require('inquirer');
+
+async function build(target, options) {
+    console.log(chalk.bold('\n🔨 Select Build\n'));
+
+    // Load config
+    const configPath = path.resolve(process.cwd(), 'select.json');
+
+    if (!await fs.pathExists(configPath)) {
+        console.log(chalk.red('❌ No select.json found. Run "slct init" first.\n'));
+        process.exit(1);
+    }
+
+    const config = await fs.readJson(configPath);
+
+    // If no target specified, ask
+    if (!target) {
+        const answers = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'target',
+                message: 'Build target:',
+                choices: [
+                    { name: 'Web', value: 'web' },
+                    { name: 'Desktop (Windows/macOS/Linux)', value: 'desktop' },
+                    { name: 'All platforms', value: 'all' }
+                ]
+            }
+        ]);
+        target = answers.target;
+    }
+
+    // Build based on target
+    try {
+        if (target === 'all') {
+            await buildWeb(config, options);
+            await buildDesktop(config, options);
+        } else if (target === 'web') {
+            await buildWeb(config, options);
+        } else if (target === 'desktop') {
+            await buildDesktop(config, options);
+        } else {
+            console.log(chalk.red(`❌ Unknown target: ${target}`));
+            console.log(chalk.gray('   Valid targets: web, desktop, all\n'));
+            process.exit(1);
+        }
+    } catch (error) {
+        console.error(chalk.red(`\n❌ Build failed: ${error.message}\n`));
+        process.exit(1);
+    }
+}
+
+// ==================== WEB BUILD ====================
+async function buildWeb(config, options) {
+    console.log(chalk.blue('\n📦 Building for Web...\n'));
+
+    const spinner = ora('Running build command...').start();
+
+    try {
+        execSync(config.build?.command || 'npm run build', {
+            stdio: 'inherit',
+            cwd: process.cwd()
+        });
+        spinner.succeed('Web build complete!');
+        console.log(chalk.gray(`   Output: ${config.build?.outDir || 'dist'}/\n`));
+    } catch (error) {
+        spinner.fail('Web build failed');
+        throw error;
+    }
+}
+
+// ==================== DESKTOP BUILD ====================
+async function buildDesktop(config, options) {
+    const framework = options.electron ? 'electron' : (config.desktop?.framework || 'tauri');
+
+    console.log(chalk.blue(`\n🖥️  Building for Desktop (${framework})...\n`));
+
+    if (framework === 'tauri') {
+        await buildTauri(config, options);
+    } else {
+        await buildElectron(config, options);
+    }
+}
+
+async function buildTauri(config, options) {
+    // Check if Tauri is installed
+    const tauriInstalled = await checkTauriInstalled();
+
+    if (!tauriInstalled) {
+        console.log(chalk.yellow('\n⚠️  Tauri is not installed. Setting up...\n'));
+        await setupTauri();
+    }
+
+    // Check if Tauri is initialized in project
+    const tauriConfigPath = path.join(process.cwd(), 'src-tauri', 'tauri.conf.json');
+    if (!await fs.pathExists(tauriConfigPath)) {
+        console.log(chalk.yellow('⚠️  Tauri not initialized in project. Initializing...\n'));
+
+        try {
+            execSync('npx tauri init', { stdio: 'inherit' });
+        } catch (error) {
+            console.log(chalk.red('\n❌ Failed to initialize Tauri.'));
+            await showTauriSetupInstructions();
+            process.exit(1);
+        }
+    }
+
+    // Build
+    const spinner = ora('Building with Tauri...').start();
+    try {
+        const buildCmd = options.release ? 'npx tauri build' : 'npx tauri build --debug';
+        execSync(buildCmd, { stdio: 'inherit' });
+        spinner.succeed('Tauri build complete!');
+        console.log(chalk.gray('   Output: src-tauri/target/release/\n'));
+    } catch (error) {
+        spinner.fail('Tauri build failed');
+        await showTauriSetupInstructions();
+        throw error;
+    }
+}
+
+async function buildElectron(config, options) {
+    // Check if Electron builder is installed
+    const electronInstalled = await checkPackageInstalled('electron');
+
+    if (!electronInstalled) {
+        console.log(chalk.yellow('\n⚠️  Electron is not installed. Setting up...\n'));
+
+        const spinner = ora('Installing Electron dependencies...').start();
+        try {
+            execSync('npm install --save-dev electron electron-builder', { stdio: 'pipe' });
+            spinner.succeed('Electron installed!');
+        } catch (error) {
+            spinner.fail('Failed to install Electron');
+            throw error;
+        }
+    }
+
+    // Check if electron main file exists
+    const mainPath = path.join(process.cwd(), 'electron', 'main.js');
+    if (!await fs.pathExists(mainPath)) {
+        console.log(chalk.yellow('⚠️  Creating Electron configuration...\n'));
+        await createElectronConfig(config);
+    }
+
+    // Build
+    const spinner = ora('Building with Electron...').start();
+    try {
+        execSync('npx electron-builder', { stdio: 'inherit' });
+        spinner.succeed('Electron build complete!');
+        console.log(chalk.gray('   Output: dist-electron/\n'));
+    } catch (error) {
+        spinner.fail('Electron build failed');
+        throw error;
+    }
+}
+
+// ==================== MOBILE BUILD ====================
+async function buildMobile(config, options) {
+    console.log(chalk.blue('\n📱 Building for Mobile (Capacitor)...\n'));
+
+    // Check if Capacitor is installed
+    const capInstalled = await checkPackageInstalled('@capacitor/core');
+
+    if (!capInstalled) {
+        console.log(chalk.yellow('\n⚠️  Capacitor is not installed. Setting up...\n'));
+        await setupCapacitor(config);
+    }
+
+    // Build web first
+    await buildWeb(config, options);
+
+    // Sync Capacitor
+    const spinner = ora('Syncing Capacitor...').start();
+    try {
+        execSync('npx cap sync', { stdio: 'pipe' });
+        spinner.succeed('Capacitor synced!');
+    } catch (error) {
+        spinner.fail('Capacitor sync failed');
+        throw error;
+    }
+
+    console.log(chalk.green('\n✅ Mobile build ready!'));
+    console.log(chalk.gray(`
+   To build native apps:
+   
+   Android:
+     ${chalk.cyan('npx cap open android')}
+     Build in Android Studio
+   
+   iOS:
+     ${chalk.cyan('npx cap open ios')}
+     Build in Xcode
+`));
+}
+
+// ==================== SETUP FUNCTIONS ====================
+async function checkTauriInstalled() {
+    try {
+        execSync('cargo --version', { stdio: 'pipe' });
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+async function checkPackageInstalled(packageName) {
+    try {
+        const packageJsonPath = path.join(process.cwd(), 'package.json');
+        const pkg = await fs.readJson(packageJsonPath);
+        return !!(pkg.dependencies?.[packageName] || pkg.devDependencies?.[packageName]);
+    } catch {
+        return false;
+    }
+}
+
+async function showTauriSetupInstructions() {
+    console.log(chalk.yellow(`
+╔════════════════════════════════════════════════════════════════╗
+║                    TAURI SETUP REQUIRED                        ║
+╚════════════════════════════════════════════════════════════════╝
+
+Tauri requires Rust and platform-specific build tools.
+
+${chalk.bold('Step 1: Install Rust')}
+${chalk.cyan('  https://rustup.rs/')}
+  Run: ${chalk.white('curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh')}
+  Or on Windows: Download and run rustup-init.exe
+
+${chalk.bold('Step 2: Install Visual Studio Build Tools (Windows Only)')}
+${chalk.cyan('  https://visualstudio.microsoft.com/visual-cpp-build-tools/')}
+  
+  Required components:
+  ${chalk.white('• MSVC v143 - VS 2022 C++ x64/x86 build tools')}
+  ${chalk.white('• Windows 10/11 SDK')}
+  ${chalk.white('• C++ CMake tools for Windows')}
+
+${chalk.bold('Step 3: Install Tauri CLI')}
+  ${chalk.cyan('npm install -g @tauri-apps/cli')}
+  
+${chalk.bold('Step 4: Verify Installation')}
+  ${chalk.cyan('rustc --version')}
+  ${chalk.cyan('cargo --version')}
+
+${chalk.bold('Step 5: Re-run Select Build')}
+  ${chalk.cyan('slct build desktop')}
+
+${chalk.gray('For more info: https://tauri.app/v1/guides/getting-started/prerequisites')}
+`));
+}
+
+async function setupTauri() {
+    await showTauriSetupInstructions();
+
+    const answers = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'continue',
+            message: 'Have you installed Rust and build tools?',
+            default: false
+        }
+    ]);
+
+    if (!answers.continue) {
+        console.log(chalk.yellow('\n⚠️  Please install the requirements and try again.\n'));
+        process.exit(1);
+    }
+
+    // Install Tauri CLI
+    const spinner = ora('Installing Tauri CLI...').start();
+    try {
+        execSync('npm install --save-dev @tauri-apps/cli @tauri-apps/api', { stdio: 'pipe' });
+        spinner.succeed('Tauri CLI installed!');
+    } catch (error) {
+        spinner.fail('Failed to install Tauri CLI');
+        throw error;
+    }
+}
+
+async function setupCapacitor(config) {
+    console.log(chalk.blue(`
+╔════════════════════════════════════════════════════════════════╗
+║                  CAPACITOR SETUP                               ║
+╚════════════════════════════════════════════════════════════════╝
+
+Setting up Capacitor for mobile builds...
+`));
+
+    const spinner = ora('Installing Capacitor...').start();
+    try {
+        execSync('npm install @capacitor/core @capacitor/cli', { stdio: 'pipe' });
+        spinner.succeed('Capacitor core installed!');
+    } catch (error) {
+        spinner.fail('Failed to install Capacitor');
+        throw error;
+    }
+
+    // Initialize Capacitor
+    const spinner2 = ora('Initializing Capacitor...').start();
+    try {
+        execSync(`npx cap init "${config.name}" com.select.${config.name.replace(/-/g, '')} --web-dir dist`, {
+            stdio: 'pipe'
+        });
+        spinner2.succeed('Capacitor initialized!');
+    } catch (error) {
+        spinner2.fail('Failed to initialize Capacitor');
+        throw error;
+    }
+
+    // Ask which platforms to add
+    const answers = await inquirer.prompt([
+        {
+            type: 'checkbox',
+            name: 'platforms',
+            message: 'Add mobile platforms:',
+            choices: [
+                { name: 'Android', value: 'android', checked: true },
+                { name: 'iOS', value: 'ios', checked: true }
+            ]
+        }
+    ]);
+
+    for (const platform of answers.platforms) {
+        const spinner3 = ora(`Adding ${platform}...`).start();
+        try {
+            execSync(`npm install @capacitor/${platform}`, { stdio: 'pipe' });
+            execSync(`npx cap add ${platform}`, { stdio: 'pipe' });
+            spinner3.succeed(`${platform} added!`);
+        } catch (error) {
+            spinner3.fail(`Failed to add ${platform}`);
+        }
+    }
+
+    console.log(chalk.green('\n✅ Capacitor setup complete!\n'));
+
+    if (answers.platforms.includes('android')) {
+        console.log(chalk.gray(`   Android: Install Android Studio from ${chalk.cyan('https://developer.android.com/studio')}`));
+    }
+    if (answers.platforms.includes('ios')) {
+        console.log(chalk.gray(`   iOS: Requires macOS with Xcode installed`));
+    }
+    console.log('');
+}
+
+async function createElectronConfig(config) {
+    const electronDir = path.join(process.cwd(), 'electron');
+    await fs.ensureDir(electronDir);
+
+    // Create main.js
+    const mainJs = `const { app, BrowserWindow } = require('electron');
+const path = require('path');
+
+function createWindow() {
+    const win = new BrowserWindow({
+        width: 1200,
+        height: 800,
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true
+        }
+    });
+
+    // Load the built app
+    win.loadFile(path.join(__dirname, '../dist/index.html'));
+}
+
+app.whenReady().then(createWindow);
+
+app.on('window-all-closed', () => {
+    if (process.platform !== 'darwin') app.quit();
+});
+
+app.on('activate', () => {
+    if (BrowserWindow.getAllWindows().length === 0) createWindow();
+});
+`;
+
+    await fs.writeFile(path.join(electronDir, 'main.js'), mainJs);
+
+    // Update package.json
+    const pkgPath = path.join(process.cwd(), 'package.json');
+    const pkg = await fs.readJson(pkgPath);
+    pkg.main = 'electron/main.js';
+    pkg.build = {
+        appId: `com.select.${config.name.replace(/-/g, '')}`,
+        productName: config.name,
+        directories: {
+            output: 'dist-electron'
+        },
+        files: [
+            'dist/**/*',
+            'electron/**/*'
+        ]
+    };
+    await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+
+    console.log(chalk.green('   Electron configuration created!\n'));
+}
+
+module.exports = build;

package/lib/commands/deploy.js

@@ -0,0 +1,187 @@
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const inquirer = require('inquirer');
+const ora = require('ora');
+const axios = require('axios');
+const FormData = require('form-data');
+const archiver = require('archiver');
+const os = require('os');
+const { glob } = require('glob'); // Using glob pattern matching if available, or manual find
+
+async function deploy(options) {
+    console.log(chalk.bold('\n🚀 Deploy to Select\n'));
+
+    // Load config
+    const configPath = path.resolve(process.cwd(), 'select.json');
+    if (!await fs.pathExists(configPath)) {
+        console.log(chalk.red('❌ No select.json found. Run "slct init" first.\n'));
+        process.exit(1);
+    }
+    const config = await fs.readJson(configPath);
+    const API_URL = process.env.SELECT_API_URL || 'http://localhost:3001';
+
+    // Collect deploy information
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'App name:',
+            default: config.name
+        },
+        {
+            type: 'input',
+            name: 'tagline',
+            message: 'Tagline:',
+            default: config.description || 'An awesome app'
+        },
+        {
+            type: 'list',
+            name: 'category',
+            message: 'Category:',
+            choices: ['Productivity', 'Finance', 'Developer Tools', 'Education', 'Entertainment', 'Utilities', 'Other'],
+            default: config.category || 'Productivity'
+        },
+        {
+            type: 'password',
+            name: 'deployKey',
+            message: 'Deploy Key:',
+            mask: '*'
+        },
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Deploy to ${API_URL}?`,
+            default: true
+        }
+    ]);
+
+    if (!answers.confirm) return;
+
+    const spinner = ora('Looking for build artifacts...').start();
+
+    // Prepare FormData
+    const form = new FormData();
+    const manifest = {
+        ...config,
+        name: answers.name,
+        tagline: answers.tagline,
+        category: answers.category.toLowerCase().replace(' ', '-'),
+        platforms: []
+    };
+
+    // Find artifacts (Tauri logic)
+    const tauriTarget = path.join(process.cwd(), 'src-tauri', 'target', 'release', 'bundle');
+    let foundArtifacts = 0;
+
+    // Windows
+    if (config.platforms.includes('windows')) {
+        const winPath = path.join(tauriTarget, 'nsis');
+        if (await fs.pathExists(winPath)) {
+            const files = await fs.readdir(winPath);
+            const exe = files.find(f => f.endsWith('.exe'));
+            if (exe) {
+                form.append('windows', fs.createReadStream(path.join(winPath, exe)));
+                manifest.platforms.push('windows');
+                foundArtifacts++;
+                spinner.text = `Found Windows binary: ${exe}`;
+            }
+        }
+    }
+
+    // macOS
+    if (config.platforms.includes('macos')) {
+        const macPath = path.join(tauriTarget, 'dmg');
+        if (await fs.pathExists(macPath)) {
+            const files = await fs.readdir(macPath);
+            const dmg = files.find(f => f.endsWith('.dmg'));
+            if (dmg) {
+                form.append('macos', fs.createReadStream(path.join(macPath, dmg)));
+                manifest.platforms.push('macos');
+                foundArtifacts++;
+                spinner.text = `Found macOS binary: ${dmg}`;
+            }
+        }
+    }
+
+    // Linux
+    if (config.platforms.includes('linux')) {
+        const linuxPath = path.join(tauriTarget, 'appimage');
+        if (await fs.pathExists(linuxPath)) {
+            const files = await fs.readdir(linuxPath);
+            const appImg = files.find(f => f.endsWith('.AppImage'));
+            if (appImg) {
+                form.append('linux', fs.createReadStream(path.join(linuxPath, appImg)));
+                manifest.platforms.push('linux');
+                foundArtifacts++;
+                spinner.text = `Found Linux binary: ${appImg}`;
+            }
+        }
+    }
+
+    // Web App
+    if (config.platforms.includes('web')) {
+        const buildDir = path.resolve(process.cwd(), config.build?.outDir || 'dist');
+        if (await fs.pathExists(buildDir)) {
+            const zipPath = path.join(os.tmpdir(), `web-build-${Date.now()}.zip`);
+            const output = fs.createWriteStream(zipPath);
+            const archive = archiver('zip', { zlib: { level: 9 } });
+
+            spinner.text = 'Zipping web build...';
+
+            await new Promise((resolve, reject) => {
+                output.on('close', resolve);
+                archive.on('error', reject);
+                archive.pipe(output);
+                archive.directory(buildDir, false);
+                archive.finalize();
+            });
+
+            form.append('web', fs.createReadStream(zipPath));
+            manifest.platforms.push('web');
+            foundArtifacts++;
+        } else {
+            spinner.warn('Web build directory not found (skipping web upload)');
+        }
+    } else if (foundArtifacts === 0) { // Only error if NO artifacts found and web not requested
+        spinner.fail('No build artifacts found!');
+        console.log(chalk.yellow('\nTip: Run "slct build desktop" or "slct build web" first.\n'));
+        return;
+    }
+
+    form.append('manifest', JSON.stringify(manifest));
+
+    spinner.text = 'Uploading to Select...';
+
+    try {
+        const response = await axios.post(`${API_URL}/api/deploy`, form, {
+            headers: {
+                ...form.getHeaders(),
+                'Authorization': `Bearer ${answers.deployKey}`
+            },
+            maxContentLength: Infinity,
+            maxBodyLength: Infinity
+        });
+
+        spinner.succeed('Deployment successful!');
+        console.log(chalk.green(`
+╔════════════════════════════════════════════════════════════════╗
+║                    ✅ DEPLOYED SUCCESSFULLY                    ║
+╚════════════════════════════════════════════════════════════════╝
+  
+  App:     ${response.data.slug}
+  Version: ${response.data.version}
+  URL:     ${API_URL}/apps/${response.data.slug}
+`));
+
+    } catch (error) {
+        spinner.fail('Deployment failed');
+        if (error.response) {
+            console.error(chalk.red(`Server Error: ${error.response.status} - ${JSON.stringify(error.response.data)}`));
+        } else {
+            console.error(chalk.red(`Error: ${error.message}`));
+        }
+    }
+}
+
+module.exports = deploy;

package/lib/commands/dev.js

@@ -0,0 +1,55 @@
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const { spawn } = require('child_process');
+
+async function dev(options) {
+    console.log(chalk.bold('\n🔧 Starting Development Server\n'));
+
+    // Load config
+    const configPath = path.resolve(process.cwd(), 'select.json');
+    let devCommand = 'npm run dev';
+
+    if (await fs.pathExists(configPath)) {
+        const config = await fs.readJson(configPath);
+        devCommand = config.build?.devCommand || devCommand;
+    }
+
+    console.log(chalk.gray(`   Running: ${devCommand}\n`));
+
+    // Parse command
+    const parts = devCommand.split(' ');
+    const cmd = parts[0];
+    const args = parts.slice(1);
+
+    // Add port if specified
+    if (options.port && options.port !== '5173') {
+        args.push('--port', options.port);
+    }
+
+    // Spawn dev server
+    const child = spawn(cmd, args, {
+        stdio: 'inherit',
+        shell: true,
+        cwd: process.cwd()
+    });
+
+    child.on('error', (error) => {
+        console.error(chalk.red(`\n❌ Failed to start dev server: ${error.message}\n`));
+        process.exit(1);
+    });
+
+    child.on('close', (code) => {
+        if (code !== 0) {
+            console.log(chalk.yellow(`\n⚠️  Dev server exited with code ${code}\n`));
+        }
+    });
+
+    // Handle Ctrl+C
+    process.on('SIGINT', () => {
+        child.kill('SIGINT');
+        process.exit(0);
+    });
+}
+
+module.exports = dev;

package/lib/commands/init.js

@@ -0,0 +1,295 @@
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const inquirer = require('inquirer');
+const ora = require('ora');
+
+async function init(name, options) {
+    console.log(chalk.bold('\n📦 Initialize Select Project\n'));
+
+    // If no name provided, ask for it
+    if (!name) {
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'name',
+                message: 'Project name:',
+                default: 'my-select-app',
+                validate: (input) => {
+                    if (/^[a-z0-9-]+$/.test(input)) return true;
+                    return 'Project name must be lowercase with hyphens only';
+                }
+            }
+        ]);
+        name = answers.name;
+    }
+
+    const projectDir = path.resolve(process.cwd(), name);
+
+    // Check if directory exists
+    if (await fs.pathExists(projectDir)) {
+        console.log(chalk.red(`\n❌ Directory "${name}" already exists.\n`));
+        process.exit(1);
+    }
+
+    // Ask for project details
+    const answers = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'template',
+            message: 'Select a template:',
+            choices: [
+                { name: 'React + Vite', value: 'react' },
+                { name: 'Vue + Vite', value: 'vue' },
+                { name: 'Vanilla JavaScript', value: 'vanilla' }
+            ],
+            default: options.template
+        },
+        {
+            type: 'checkbox',
+            name: 'platforms',
+            message: 'Target platforms:',
+            choices: [
+                { name: 'Web', value: 'web', checked: true },
+                { name: 'Windows', value: 'windows' },
+                { name: 'macOS', value: 'macos' },
+                { name: 'Linux', value: 'linux' }
+            ]
+        },
+        {
+            type: 'list',
+            name: 'desktopFramework',
+            message: 'Desktop framework:',
+            choices: [
+                { name: 'Tauri (Recommended - smaller, faster)', value: 'tauri' },
+                { name: 'Electron (Larger, more compatible)', value: 'electron' }
+            ],
+            when: (ans) => ans.platforms.some(p => ['windows', 'macos', 'linux'].includes(p))
+        }
+    ]);
+
+    const spinner = ora('Creating project...').start();
+
+    try {
+        // Create project directory
+        await fs.ensureDir(projectDir);
+
+        // Create select.json config
+        const selectConfig = {
+            name: name,
+            version: '1.0.0',
+            description: 'A Select app',
+            platforms: answers.platforms,
+            desktop: {
+                framework: answers.desktopFramework || 'tauri'
+            },
+            build: {
+                command: 'npm run build',
+                devCommand: 'npm run dev',
+                outDir: 'dist'
+            }
+        };
+
+        await fs.writeJson(path.join(projectDir, 'select.json'), selectConfig, { spaces: 2 });
+
+        // Create basic package.json
+        const packageJson = {
+            name: name,
+            version: '1.0.0',
+            private: true,
+            scripts: {
+                dev: 'vite',
+                build: 'vite build',
+                preview: 'vite preview',
+                'slct:build': 'slct build all',
+                'slct:deploy': 'slct deploy'
+            },
+            dependencies: {},
+            devDependencies: {
+                'vite': '^5.0.0'
+            }
+        };
+
+        // Add template-specific dependencies
+        if (answers.template === 'react') {
+            packageJson.dependencies['react'] = '^18.2.0';
+            packageJson.dependencies['react-dom'] = '^18.2.0';
+            packageJson.devDependencies['@vitejs/plugin-react'] = '^4.2.0';
+        } else if (answers.template === 'vue') {
+            packageJson.dependencies['vue'] = '^3.4.0';
+            packageJson.devDependencies['@vitejs/plugin-vue'] = '^4.5.0';
+        }
+
+        await fs.writeJson(path.join(projectDir, 'package.json'), packageJson, { spaces: 2 });
+
+        // Create basic index.html
+        const indexHtml = `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>${name}</title>
+</head>
+<body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.${answers.template === 'vanilla' ? 'js' : answers.template === 'react' ? 'jsx' : 'js'}"></script>
+</body>
+</html>`;
+
+        await fs.writeFile(path.join(projectDir, 'index.html'), indexHtml);
+
+        // Create src directory with basic file
+        await fs.ensureDir(path.join(projectDir, 'src'));
+
+        // Create GitHub Actions workflow
+        await createGithubWorkflow(projectDir, answers.desktopFramework || 'tauri', name);
+
+        if (answers.template === 'react') {
+            await fs.writeFile(path.join(projectDir, 'src', 'main.jsx'), `import React from 'react'
+import ReactDOM from 'react-dom/client'
+
+function App() {
+    return (
+        <div style={{ padding: '2rem', fontFamily: 'system-ui' }}>
+            <h1>Welcome to ${name}</h1>
+            <p>Built with Select CLI</p>
+        </div>
+    )
+}
+
+ReactDOM.createRoot(document.getElementById('app')).render(<App />)
+`);
+        } else {
+            await fs.writeFile(path.join(projectDir, 'src', 'main.js'), `document.getElementById('app').innerHTML = \`
+    <div style="padding: 2rem; font-family: system-ui;">
+        <h1>Welcome to ${name}</h1>
+        <p>Built with Select CLI</p>
+    </div>
+\`
+`);
+        }
+
+        spinner.succeed('Project created successfully!');
+
+        console.log(chalk.green(`
+✅ Project "${name}" created!
+
+Next steps:
+  ${chalk.cyan(`cd ${name}`)}
+  ${chalk.cyan('npm install')}
+  ${chalk.cyan('slct build')}
+
+`));
+
+        // Check for required dependencies
+        await checkDependencies(answers);
+
+    } catch (error) {
+        spinner.fail('Failed to create project');
+        console.error(chalk.red(error.message));
+        process.exit(1);
+    }
+}
+
+async function checkDependencies(answers) {
+    const hasDesktop = answers.platforms?.some(p => ['windows', 'macos', 'linux'].includes(p));
+
+    if (hasDesktop && answers.desktopFramework === 'tauri') {
+        console.log(chalk.yellow('\n⚠️  Tauri Requirements:'));
+        console.log(chalk.gray('   Run "slct build desktop" for detailed setup instructions.\n'));
+    }
+}
+
+async function createGithubWorkflow(projectDir, framework, name) {
+    const workflowDir = path.join(projectDir, '.github', 'workflows');
+    await fs.ensureDir(workflowDir);
+
+    let workflowContent = '';
+
+    if (framework === 'tauri') {
+        workflowContent = `name: Build Apps
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build-tauri:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [macos-latest, ubuntu-22.04, windows-latest]
+
+    runs-on: \${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: setup node
+        uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+
+      - name: install Rust stable
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: install dependencies (ubuntu only)
+        if: matrix.platform == 'ubuntu-22.04'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libgtk-3-dev libwebkit2gtk-4.0-dev libappindicator3-dev librsvg2-dev patchelf
+
+      - name: install frontend dependencies
+        run: npm install
+
+      - name: build tauri
+        uses: tauri-apps/tauri-action@v0
+        env:
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+        with:
+          tagName: app-v__VERSION__ # the action automatically replaces \`__VERSION__\` with the app version
+          releaseName: 'App v__VERSION__'
+          releaseBody: 'See the assets to download this version and install.'
+          releaseDraft: true
+          prerelease: false
+`;
+    } else {
+        // Electron Workflow
+        workflowContent = `name: Build Apps
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build-electron:
+    runs-on: \${{ matrix.os }}
+
+    strategy:
+      matrix:
+        os: [macos-latest, ubuntu-latest, windows-latest]
+
+    steps:
+      - name: Check out Git repository
+        uses: actions/checkout@v4
+
+      - name: Install Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+
+      - name: Install Dependencies
+        run: npm install
+
+      - name: Build Electron App
+        run: npx electron-builder --publish always
+        env:
+          GH_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+`;
+    }
+
+    await fs.writeFile(path.join(workflowDir, 'build.yml'), workflowContent);
+}
+
+module.exports = init;

package/lib/commands/select.js

@@ -0,0 +1,64 @@
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const inquirer = require('inquirer');
+
+async function select() {
+    console.log(chalk.bold('\n🎯 Select Target Platforms\n'));
+
+    // Check if select.json exists
+    const configPath = path.resolve(process.cwd(), 'select.json');
+
+    if (!await fs.pathExists(configPath)) {
+        console.log(chalk.red('❌ No select.json found. Run "slct init" first.\n'));
+        process.exit(1);
+    }
+
+    const config = await fs.readJson(configPath);
+
+    const answers = await inquirer.prompt([
+        {
+            type: 'checkbox',
+            name: 'platforms',
+            message: 'Select platforms to build for:',
+            choices: [
+                { name: 'Web', value: 'web', checked: config.platforms?.includes('web') },
+                { name: 'Windows', value: 'windows', checked: config.platforms?.includes('windows') },
+                { name: 'macOS', value: 'macos', checked: config.platforms?.includes('macos') },
+                { name: 'Linux', value: 'linux', checked: config.platforms?.includes('linux') }
+            ],
+            validate: (input) => input.length > 0 || 'Select at least one platform'
+        }
+    ]);
+
+    const hasDesktop = answers.platforms.some(p => ['windows', 'macos', 'linux'].includes(p));
+
+    if (hasDesktop) {
+        const desktopAnswer = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'desktopFramework',
+                message: 'Desktop framework:',
+                choices: [
+                    { name: 'Tauri (Recommended - smaller, faster)', value: 'tauri' },
+                    { name: 'Electron (Larger, more compatible)', value: 'electron' }
+                ],
+                default: config.desktop?.framework || 'tauri'
+            }
+        ]);
+        config.desktop = { framework: desktopAnswer.desktopFramework };
+    }
+
+    // Update config
+    config.platforms = answers.platforms;
+    await fs.writeJson(configPath, config, { spaces: 2 });
+
+    console.log(chalk.green('\n✅ Configuration saved!'));
+    console.log(chalk.gray(`   Platforms: ${answers.platforms.join(', ')}`));
+    if (hasDesktop) {
+        console.log(chalk.gray(`   Desktop: ${config.desktop.framework}`));
+    }
+    console.log(chalk.cyan('\n   Run "slct build" to build your app.\n'));
+}
+
+module.exports = select;

package/lib/index.js

@@ -0,0 +1,7 @@
+module.exports = {
+    init: require('./commands/init'),
+    select: require('./commands/select'),
+    build: require('./commands/build'),
+    deploy: require('./commands/deploy'),
+    dev: require('./commands/dev')
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+    "name": "@iselect/select",
+    "version": "1.0.0",
+    "description": "Build and deploy apps for web, desktop, and mobile from a single codebase",
+    "main": "lib/index.js",
+    "bin": {
+        "slct": "bin/select.js"
+    },
+    "scripts": {
+        "test": "echo \"Tests coming soon\""
+    },
+    "keywords": [
+        "select",
+        "cli",
+        "tauri",
+        "electron",
+        "capacitor",
+        "cross-platform",
+        "build",
+        "deploy"
+    ],
+    "author": "Select",
+    "license": "MIT",
+    "dependencies": {
+        "archiver": "^7.0.1",
+        "axios": "^1.13.2",
+        "chalk": "^4.1.2",
+        "commander": "^11.1.0",
+        "form-data": "^4.0.5",
+        "fs-extra": "^11.2.0",
+        "inquirer": "^8.2.6",
+        "ora": "^5.4.1",
+        "semver": "^7.5.4"
+    },
+    "engines": {
+        "node": ">=16.0.0"
+    }
+}