Liteshow

Developer-First, SEO-Optimized, Git-Powered CMS

Liteshow is a content management system that combines a powerful AI content assistant with a robust, developer-friendly architecture, ensuring every site is perfectly optimized for SEO from day one.

---

🚧 MVP Development Progress

Current Status: Phase 3.4 Complete ✅ | GitHub Pages Deployment Fully Functional 🚀

Phase 1: Core Infrastructure & Authentication ✅

• Database setup with Drizzle ORM (PostgreSQL + Turso)
• Better Auth with GitHub OAuth (repo scope)
• Next.js dashboard with Tailwind CSS
• Hono API server with health checks
• Shared UI component library
• TypeScript configuration across monorepo
• All packages build successfully

Phase 2.1: Project Creation Flow ✅

• Project creation form with validation
• Automated Turso database provisioning per project
• GitHub repository creation with initial commit
• Database schema initialization (pages and blocks tables)
• Project detail page with configuration display

Phase 2.2: Content Management ✅

• Page CRUD operations (create, read, update, delete)
• Block CRUD operations with drag-and-drop ordering
• Block types: hero, features, testimonials, markdown, CTA, FAQ
• Content editor UI with block management
• Block editing with JSON content forms
• Draft/published status workflow
• shadcn/ui components with dark mode

Phase 2.3: Astro Frontend ✅

• Astro SSR site with server-side rendering
• Dynamic routing via [slug].astro
• Beautiful block components with Tailwind CSS
• Database integration (fetch from project Turso)
• Published-only page visibility
• Responsive mobile-first design
• Inter font and modern UI styling

Phase 2.4: Remaining Content Features ✅

• Git sync for content changes (push to GitHub on publish)
• Activity feed integration
• Content versioning (snapshots on update, history, restore)
• Draft/publish workflow (unpublished changes indicator, explicit publish)
• Novel editor integration for markdown blocks and blog pages

Phase 3: Deployment Setup ✅

• Public content API for fetching published content
• Complete Astro site auto-generated in GitHub repos
• All 6 block components (Hero, Features, Testimonials, CTA, Markdown, FAQ)
• Static site generation (SSG) for optimal performance
• Automated deployment config files (netlify.toml, vercel.json, package.json)
• "Deploy to X" buttons in README for one-click setup
• Astro site fetches content from API at build time (no database credentials needed)
• Simplified deployment with env vars (LITESHOW_PROJECT_SLUG, LITESHOW_API_URL)
• Auto-deploy on publish via platform Git integration (no GitHub Actions needed)

Phase 3.1: Dependency Updates & Cleanup ✅

• Updated Next.js 14 → 16, React 18 → 19
• Updated Astro 4 → 5 with Node adapter
• Updated Drizzle ORM 0.29 → 0.45
• Updated Hono 4.0 → 4.11
• Fixed all dependency conflicts
• Cleaned up outdated documentation files
• Verified all builds and deployments working

Phase 3.2: API Production Deployment ✅

• Deployed Liteshow API to Fly.io at liteshow-api.fly.dev
• Configured custom domain api.liteshow.io (SSL pending)
• Set up GitHub integration for automated deployments
• Implemented lazy database initialization for improved startup
• Routes simplified (no /api prefix needed)
• Health checks and monitoring configured
• Multi-stage Docker build with tsx runtime
• Environment variables secured in Fly.io secrets

Phase 3.3: GitHub App Integration ✅

• Create Liteshow GitHub App with repository permissions
• User installs GitHub App to grant fine-grained repository access
• GitHub App callback and installation flow
• Repository selection UI (list all accessible repos)
• Link existing repositories to projects via GitHub App
• Store GitHub App installation tokens and metadata
• Support both OAuth (create-now) and GitHub App (link-existing) strategies
• Progressive permission flow with minimal initial scope
• Environment variable based GitHub App configuration
• Fixed markdown rendering in MarkdownBlock component (added marked parser)
• Enhanced toast notifications with descriptions and rich colors
• Fixed homepage to show page list when no /home page exists
• Removed problematic Netlify redirect rules from template

Phase 3.4: GitHub Pages Deployment ✅

• Renamed "Publish/Published" to "Save/Saved" throughout the application
• Added deployment infrastructure to database schema
• Created Deployment tab UI with status, settings, and history
• Implemented GitHub Actions workflow for automated deployments
• Created deployment API routes (deploy, settings, history, status, sync)
• Integrated GitHub API to trigger and monitor deployments
• Added real-time deployment status polling with useDeploymentStatus hook
• Created deployment status indicator in project header
• Implemented custom domain configuration UI and API
• DNS instructions with CNAME record details

Phase 3.5: Advanced Deployment Options 📋

• Self-hosting mode (direct Turso connection for users who want full control)
• SQLite database export/download feature
• Option to BYO database (bring your own Turso/SQLite instance)
• Migration tool to export project and all content
• Documentation for running Liteshow infrastructure yourself

Phase 4: AI Content Assistant 📋

• Anthropic Claude API integration
• Natural language content generation
• Block generation from AI prompts
• Preview/approve workflow for AI changes
• AI chat interface in dashboard
• Diff view for content changes

Phase 5: SEO & Domain Management 📋

• SEO optimization (meta tags, sitemaps, structured data)
• Custom domain configuration
• Domain verification system
• SSL certificate management
• Analytics integration

Phase 6: Polish & Production 📋

• Complete activity logging system
• Activity feed UI with filtering
• Error handling and validation improvements
• Performance optimization
• Comprehensive testing
• Documentation completion
• Production deployment

Legend: ✅ Complete | 🚧 In Progress | 📋 Planned

---

Features

• AI-Powered Content Creation: Natural language interface for content management
• Block-Based Content Model: Flexible, reusable content blocks
• SEO-First: Built with Astro for best-in-class performance and SEO
• Git-Backed: All content version-controlled in your own GitHub repository
• Multi-Tenant: Each project gets its own isolated database
• Custom Domains: Easy custom domain configuration

Architecture

This is a monorepo containing:

• apps/dashboard: Next.js user dashboard (to be deployed to Vercel)
• apps/sites: Astro site generator (user sites deployed to Netlify/Vercel/Cloudflare Pages)
• apps/api: Hono backend API (deployed to Fly.io)
• packages/ui: Shared React components
• packages/auth: Better Auth configuration
• packages/db: Drizzle ORM schema and client
• packages/config: Shared configuration

Deployment Strategy

• API: Production deployment at api.liteshow.io (Fly.io)

  • Automated deployments via GitHub integration
  • Lazy database initialization for fast startup
  • Health monitoring and auto-scaling
  • Environment variables managed via Fly.io secrets

• Templates: Astro site templates stored in separate repository

  • Repository: liteshowcms/templates
  • Templates are fetched from GitHub at runtime via API
  • No API redeployment needed when templates are updated
  • Used for both initial project creation and template sync

• Dashboard: Deployed to Vercel at liteshow-dashboard.vercel.app

  • Production deployments active and running
  • All API calls integrated with production API
  • Auto-deploys from main branch via GitHub integration

• User Sites: Auto-generated Astro sites deployed to user's choice of:

  • Netlify (recommended)
  • Vercel
  • Cloudflare Pages
  • Any static host

Production API

The Liteshow API is live and accessible at:

• Primary: https://liteshow-api.fly.dev/
• Custom Domain: https://api.liteshow.io/ (SSL certificate provisioning)

Available Endpoints:

• GET / - API status and version
• GET /health - Health check endpoint
• GET /public/:projectSlug/pages - Fetch all published pages
• GET /public/:projectSlug/pages/:slug - Fetch specific page with blocks
• Authentication and project management endpoints (authenticated)

Getting Started

Prerequisites

• Node.js >= 18.0.0
• pnpm >= 8.0.0
• PostgreSQL database (choose one):
  • Option A: Managed database (Neon, Supabase, Railway) - Recommended for easy setup
  • Option B: Docker Compose (local PostgreSQL)
  • Option C: Local PostgreSQL installation
• Turso account (for content databases)
• GitHub OAuth App

Quick Start (Managed Database - Recommended)

This is the easiest way to get started without managing a database server:

1. Create a managed PostgreSQL database:

   • Neon (free tier available) - Recommended
   • Supabase (free tier available)
   • Railway (free trial)

2. Clone and install:

   git clone https://github.com/perryraskin/liteshow.git
   cd liteshow
   pnpm install

3. Set up environment variables:

   cp .env.example .env
   # Edit .env and add your DATABASE_URL from Neon/Supabase

4. Create a Turso database:

   # Install Turso CLI
   curl -sSfL https://get.tur.so/install.sh | bash
   
   # Sign up and create a database
   turso auth signup
   turso db create liteshow
   turso db tokens create liteshow

5. Create a GitHub OAuth App:

   • Go to GitHub Settings > Developer settings > OAuth Apps
   • Create new OAuth App
   • Homepage URL: http://localhost:3000
   • Callback URL: http://localhost:8000/api/auth/callback/github
   • Add Client ID and Secret to .env

6. Run database migrations:

   cd packages/db
   pnpm db:push
   cd ../..

7. Start development servers:

   pnpm dev

   This will start:

   • Dashboard: http://localhost:3000
   • API: http://localhost:8000

Local Setup with Docker

If you prefer to run everything locally including the database:

# Start PostgreSQL with Docker Compose
docker-compose up -d

# Follow steps 2-7 above

See the Self-Hosting Guide for detailed instructions.

Documentation

• Architecture Overview
• Content Model
• AI Workflow
• Deployment

License

MIT License - see LICENSE for details.

Contributing

Contributions are welcome! Please read our Contributing Guide first.