create-snappy 1.0.0

package/README.md

@@ -0,0 +1,35 @@
+# @snappy-stack/cli
+
+The official CLI installer to bootstrap the SNAPPY Stack.
+
+The SNAPPY Stack is a high-performance, opinionated architecture built exclusively on **Next.js 16**, **Payload CMS 3.0**, and **Tailwind CSS**.
+
+## Usage
+
+You can create a new SNAPPY project interactively by running:
+
+```bash
+npx create-snappy my-snappy-app
+```
+
+Or just run the CLI without a directory name to trigger the guided wizard:
+
+```bash
+npx create-snappy
+```
+
+## Features
+
+- **Guided Infrastructure Setup**: Automatically configs your `.env` for Supabase Postgres and S3 Storage.
+- **Private Templates**: Secured GitHub OAuth flow for accessing proprietary premium templates.
+- **Lightning Fast**: Shallow git cloning for instant scaffolding.
+
+## Requirements
+
+- `Node.js` >= 20.x
+- `pnpm` >= 9.x
+- Git
+
+## License Requirement
+
+The underlying engine (`@snappy-stack/core`) requires a valid SNAPPY Development License to function.

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "create-snappy",
+  "version": "1.0.0",
+  "description": "The official installer for the SNAPPY stack.",
+  "main": "scripts/create-snappy/cli.js",
+  "bin": {
+    "create-snappy": "./scripts/create-snappy/cli.js"
+  },
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "commander": "^14.0.3",
+    "picocolors": "^1.1.1",
+    "prompts": "^2.4.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/create-snappy/cli.js

@@ -0,0 +1,432 @@
+#!/usr/bin/env node
+
+/**
+ * create-snappy
+ * The official CLI to bootstrap the SNAPPY stack.
+ */
+
+import fs from 'fs'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { execSync } from 'child_process'
+import readline from 'readline'
+import os from 'os'
+import { Command } from 'commander'
+import prompts from 'prompts'
+import pc from 'picocolors'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const CONFIG_DIR = path.join(os.homedir(), '.snappy')
+const AUTH_FILE = path.join(CONFIG_DIR, 'auth.json')
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json')
+
+// This is the Client ID for GitHub Device OAuth
+const CLIENT_ID = 'Ov23liWHoGiMponaUxrc'
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+})
+
+const question = (query) => new Promise((resolve) => rl.question(query, resolve))
+
+// --- Auth & Config Utilities ---
+
+function getSavedToken() {
+  if (fs.existsSync(AUTH_FILE)) {
+    try {
+      const data = JSON.parse(fs.readFileSync(AUTH_FILE, 'utf8'))
+      return data.access_token
+    } catch (e) {
+      return null
+    }
+  }
+  return null
+}
+
+function saveToken(token) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true })
+  }
+  fs.writeFileSync(AUTH_FILE, JSON.stringify({ access_token: token }, null, 2))
+}
+
+function getSavedConfig() {
+  if (fs.existsSync(CONFIG_FILE)) {
+    try {
+      return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'))
+    } catch (e) {
+      return {}
+    }
+  }
+  return {}
+}
+
+function saveConfig(config) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true })
+  }
+  const current = getSavedConfig()
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify({ ...current, ...config }, null, 2))
+}
+
+async function githubLogin() {
+  console.log('\n🔐 Authenticating with GitHub...')
+
+  try {
+    const response = await fetch('https://github.com/login/device/code', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+      body: JSON.stringify({ client_id: CLIENT_ID, scope: 'repo read:user' }),
+    })
+
+    if (response.status === 404) {
+      throw new Error(
+        'GitHub returned 404. This usually means the Client ID is invalid or the app is not registered.',
+      )
+    }
+
+    const data = await response.json()
+    if (data.error) throw new Error(`Auth request failed: ${data.error_description || data.error}`)
+
+    const { device_code, user_code, verification_uri, interval, expires_in } = data
+
+    console.log(`\n1. Go to: \x1b[34m${verification_uri}\x1b[0m`)
+    console.log(`2. Enter code: \x1b[1m\x1b[32m${user_code}\x1b[0m`)
+    console.log(
+      `\nWaiting for authorization... (Expires in ${Math.floor(expires_in / 60)} minutes)`,
+    )
+
+    const poll = async () => {
+      const res = await fetch('https://github.com/login/oauth/access_token', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+        body: JSON.stringify({
+          client_id: CLIENT_ID,
+          device_code,
+          grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+        }),
+      })
+
+      const tokenData = await res.json()
+
+      if (tokenData.error) {
+        if (tokenData.error === 'authorization_pending') {
+          await new Promise((r) => setTimeout(r, (interval || 5) * 1000))
+          return poll()
+        }
+        throw new Error(`Polling failed: ${tokenData.error_description || tokenData.error}`)
+      }
+
+      return tokenData.access_token
+    }
+
+    const accessToken = await poll()
+    saveToken(accessToken)
+    console.log('✅ Successfully authenticated!')
+    return accessToken
+  } catch (err) {
+    console.warn(`\x1b[33m\n⚠️  GitHub OAuth failed: ${err.message}\x1b[0m`)
+    console.log('\x1b[36mFalling back to manual token entry...\x1b[0m')
+    const manualToken = await question('Paste your GitHub Personal Access Token (PAT): ')
+
+    if (!manualToken || manualToken.trim() === '') {
+      throw new Error('No token provided. Installation aborted.')
+    }
+
+    saveToken(manualToken.trim())
+    console.log('✅ Token saved manually.')
+    return manualToken.trim()
+  }
+}
+
+// --- Main CLI ---
+
+async function main() {
+  console.log(pc.cyan('\n🚀 Welcome to the SNAPPY Stack Installer!'))
+  console.log('------------------------------------------')
+
+  const program = new Command()
+  program
+    .name('create-snappy')
+    .description('The official installer for the SNAPPY stack. (Private Access Required)')
+    .argument('[directory]', 'Project directory name')
+    .option('-t, --template <name>', 'Template to use (main, porto)')
+    .option('--login', 'Authenticate with GitHub to access private templates')
+    .option('--guided', 'Force guided setup for environment variables')
+    .parse(process.argv)
+
+  const options = program.opts()
+  let providedName = program.args[0]
+
+  if (options.login) {
+    try {
+      await githubLogin()
+      rl.close()
+      process.exit(0)
+    } catch (e) {
+      console.error(pc.red(e.message))
+      rl.close()
+      process.exit(1)
+    }
+    return
+  }
+
+  const savedConfig = getSavedConfig()
+  const hasSavedConfig = Object.keys(savedConfig).length > 0
+
+  // INTERACTIVE PROMPTS
+  const questions = []
+
+  if (!providedName) {
+    questions.push({
+      type: 'text',
+      name: 'projectName',
+      message: 'What is your project named?',
+      initial: 'my-snappy-app',
+      validate: (value) => (value.length > 0 ? true : 'Please enter a project name.'),
+    })
+  }
+
+  questions.push({
+    type: 'text',
+    name: 'projectDescription',
+    message: 'Project description?',
+    initial: 'A fresh SNAPPY app',
+  })
+
+  questions.push({
+    type: 'text',
+    name: 'authorName',
+    message: 'Author name?',
+    initial: savedConfig.authorName || 'Wicky',
+  })
+
+  if (!options.template) {
+    questions.push({
+      type: 'select',
+      name: 'template',
+      message: 'Which template would you like to use?',
+      choices: [
+        { title: 'Portfolio', description: 'A sleek portfolio template', value: 'portofolio' },
+      ],
+      initial: 0,
+    })
+  }
+
+  // Guided Setup Questions
+  const needsGuided = options.guided || !hasSavedConfig
+
+  if (needsGuided) {
+    console.log(pc.yellow('\n🛠️  Guided Setup: Please enter your infrastructure details.'))
+    console.log(pc.gray('These will be saved to ~/.snappy/config.json for future use.\n'))
+
+    questions.push(
+      {
+        type: 'text',
+        name: 'supabaseUrl',
+        message: 'Supabase URL?',
+        initial: savedConfig.supabaseUrl || '',
+      },
+      {
+        type: 'password',
+        name: 'supabaseAnonKey',
+        message: 'Supabase Anon Key?',
+        initial: savedConfig.supabaseAnonKey || '',
+      },
+      {
+        type: 'password',
+        name: 'supabaseServiceRole',
+        message: 'Supabase Service Role Key?',
+        initial: savedConfig.supabaseServiceRole || '',
+      },
+      {
+        type: 'text',
+        name: 's3Bucket',
+        message: 'S3 Bucket Name?',
+        initial: savedConfig.s3Bucket || 'snappy-storage',
+      },
+      {
+        type: 'text',
+        name: 's3Region',
+        message: 'S3 Region?',
+        initial: savedConfig.s3Region || 'ap-southeast-1',
+      },
+      {
+        type: 'text',
+        name: 's3Endpoint',
+        message: 'S3 Endpoint URL?',
+        initial: savedConfig.s3Endpoint || '',
+      },
+      {
+        type: 'password',
+        name: 's3AccessKey',
+        message: 'S3 Access Key ID?',
+        initial: savedConfig.s3AccessKey || '',
+      },
+      {
+        type: 'password',
+        name: 's3SecretKey',
+        message: 'S3 Secret Access Key?',
+        initial: savedConfig.s3SecretKey || '',
+      },
+    )
+  }
+
+  const response = await prompts(questions, {
+    onCancel: () => {
+      console.log(pc.yellow('Installation cancelled.'))
+      process.exit(0)
+    },
+  })
+
+  // Merge responses with saved config
+  const config = {
+    ...savedConfig,
+    authorName: response.authorName || savedConfig.authorName,
+    supabaseUrl: response.supabaseUrl || savedConfig.supabaseUrl,
+    supabaseAnonKey: response.supabaseAnonKey || savedConfig.supabaseAnonKey,
+    supabaseServiceRole: response.supabaseServiceRole || savedConfig.supabaseServiceRole,
+    s3Bucket: response.s3Bucket || savedConfig.s3Bucket,
+    s3Region: response.s3Region || savedConfig.s3Region,
+    s3Endpoint: response.s3Endpoint || savedConfig.s3Endpoint,
+    s3AccessKey: response.s3AccessKey || savedConfig.s3AccessKey,
+    s3SecretKey: response.s3SecretKey || savedConfig.s3SecretKey,
+  }
+
+  // Save if it was a guided session or forced
+  if (needsGuided) {
+    saveConfig(config)
+  }
+
+  const projectName = providedName || response.projectName
+  const projectDescription = response.projectDescription
+  const authorName = config.authorName
+  const selectedTemplate = options.template || response.template || 'portofolio'
+
+  const targetDir = path.resolve(process.cwd(), projectName)
+
+  if (fs.existsSync(targetDir)) {
+    const { overwrite } = await prompts({
+      type: 'confirm',
+      name: 'overwrite',
+      message: pc.yellow(`Directory ${projectName} already exists. Overwrite?`),
+      initial: false,
+    })
+
+    if (!overwrite) {
+      console.log('Aborted.')
+      process.exit(0)
+    }
+    fs.rmSync(targetDir, { recursive: true, force: true })
+  }
+
+  // Create target dir
+  fs.mkdirSync(targetDir, { recursive: true })
+
+  try {
+  // 1. Initialize from repository
+    const token = getSavedToken() || (await githubLogin())
+
+    const repoUrl = process.env.SNAPPY_REPO_URL || 'https://github.com/snappy-stack/snappy'
+    let authenticatedUrl = repoUrl
+
+    if (token) {
+      authenticatedUrl = repoUrl.replace('https://', `https://x-access-token:${token}@`)
+    }
+
+    console.log(`Cloning into ${pc.bold(projectName)}...`)
+    try {
+      // Use branch as the template name
+      execSync(`git clone --depth 1 -b ${selectedTemplate} ${authenticatedUrl} "${targetDir}"`, {
+        stdio: 'inherit',
+      })
+    } catch (cloneErr) {
+      if (!token) {
+        console.log(pc.yellow('\n🔐 This template might be private. Attempting login...'))
+        token = await githubLogin()
+        authenticatedUrl = repoUrl.replace('https://', `https://x-access-token:${token}@`)
+        execSync(`git clone --depth 1 -b ${selectedTemplate} ${authenticatedUrl} "${targetDir}"`, {
+          stdio: 'inherit',
+        })
+      } else {
+        console.error(
+          pc.red("Clone failed. The branch might not exist, or you don't have access."),
+        )
+        throw cloneErr
+      }
+    }
+
+    if (fs.existsSync(path.join(targetDir, '.git'))) {
+      fs.rmSync(path.join(targetDir, '.git'), { recursive: true, force: true })
+    }
+    console.log(pc.green('✅ Project initialized from secure source.'))
+
+    // 2. Customize package.json and README.md
+    console.log('\n📝 Customizing project files...')
+    const pkgPath = path.join(targetDir, 'package.json')
+    if (fs.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'))
+      pkg.name = projectName.toLowerCase().replace(/\s+/g, '-')
+      pkg.description = projectDescription || pkg.description
+      pkg.author = authorName || pkg.author
+      if (pkg.bin) delete pkg.bin
+      fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2))
+    }
+
+    const readmePath = path.join(targetDir, 'README.md')
+    if (fs.existsSync(readmePath)) {
+      const readmeContent = `# ${projectName}\n\n${projectDescription}\n\nGenerated with \`create-snappy\`.`
+      fs.writeFileSync(readmePath, readmeContent)
+    }
+    console.log(pc.green('✅ Project details injected.'))
+
+    // 3. Configure .env
+    console.log('\n🛠️ Configuring environment variables...')
+    const envContent = `NEXT_PUBLIC_SUPABASE_URL="${config.supabaseUrl}"
+NEXT_PUBLIC_SUPABASE_ANON_KEY="${config.supabaseAnonKey}"
+SUPABASE_SERVICE_ROLE_KEY="${config.supabaseServiceRole}"
+SUPABASE_URL="${config.supabaseUrl}"
+
+# Database Configuration
+POSTGRES_URL="postgres://postgres:${config.supabaseServiceRole}@${config.supabaseUrl.replace('https://', '').split('.')[0]}.supabase.co:5432/postgres"
+
+# S3 Storage Configuration
+S3_BUCKET="${config.s3Bucket}"
+S3_REGION="${config.s3Region}"
+S3_ENDPOINT="${config.s3Endpoint}"
+S3_ACCESS_KEY_ID="${config.s3AccessKey}"
+S3_SECRET_ACCESS_KEY="${config.s3SecretKey}"
+
+PAYLOAD_SECRET="${Math.random().toString(36).substring(2)}"
+PUBLIC_FRONTEND_URL="http://localhost:3000"
+REQUIRE_LOGIN="yes"
+`
+    fs.writeFileSync(path.join(targetDir, '.env'), envContent)
+    console.log(pc.green('✅ .env generated.'))
+
+    if (process.env.SKIP_INSTALL !== 'true') {
+      console.log(pc.magenta('\n📦 Installing dependencies (pnpm)...'))
+      try {
+        execSync('pnpm install', { cwd: targetDir, stdio: 'inherit' })
+      } catch (e) {
+        console.warn(pc.yellow('Warning: pnpm install failed.'))
+      }
+    }
+
+    console.log(pc.green('\n✅ SNAPPY Stack is ready!'))
+    console.log(`\nNext steps:\n  cd ${pc.bold(projectName)}\n  pnpm run dev\n`)
+  } catch (err) {
+    console.error(pc.red(`Installation failed: ${err.message || err}`))
+  } finally {
+    if (rl) rl.close()
+  }
+}
+
+main().catch((err) => {
+  console.error(pc.red(err))
+  if (rl) rl.close()
+  process.exit(1)
+})