create-githat-app 0.1.1 → 0.5.0

package/LICENSE

@@ -0,0 +1,18 @@
+# License
+
+Copyright (c) 2026 GitHat. All rights reserved.
+
+This software and associated documentation files (the "Software") are the
+proprietary property of GitHat. You may use the hosted GitHat service at
+https://githat.io subject to the terms published there.
+
+You may NOT copy, modify, merge, publish, distribute, sublicense, or sell
+copies of the Software, or permit others to do so, without the prior written
+permission of GitHat.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+GITHAT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,223 +1,278 @@
 # create-githat-app
 
-**Ship authenticated apps in seconds, not weeks.**
+Scaffold a production-ready app with a fully-managed backend — auth, teams, orgs, API keys, MCP verification, and AI agent identity. **No backend to deploy.**
 
-`create-githat-app` scaffolds a complete, production-ready application with authentication, team management, and a polished dashboard — all wired up and ready to go. One command. Zero boilerplate.
+[GitHat](https://githat.io) is your backend. When you run `create-githat-app`, your generated project connects to GitHat's hosted platform at `api.githat.io`. User accounts, organizations, teams, API keys, MCP servers, and AI agents are all stored and managed by GitHat. You write frontend code only.
 
-[![npm version](https://img.shields.io/npm/v/create-githat-app.svg)](https://www.npmjs.com/package/create-githat-app)
-[![license](https://img.shields.io/npm/l/create-githat-app.svg)](https://github.com/GitHat-IO/create-githat-app/blob/main/LICENSE)
+## Install & Launch
 
----
-
-## Quick Start
+Run one command from anywhere:
 
 ```bash
-npx create-githat-app my-app
+npx create-githat-app
 ```
 
-That's it. You now have a fully functional app with sign-in, sign-up, protected routes, a dashboard, team management, API keys, and more.
+Or with a project name:
 
 ```bash
-cd my-app
-npm run dev
+npx create-githat-app my-app
 ```
 
-Open [http://localhost:3000](http://localhost:3000) and see it live.
+Or install globally:
 
----
+```bash
+npm i -g create-githat-app
+create-githat-app my-app
+```
 
-## What You Get
+The CLI launches an interactive wizard that walks you through every decision.
 
-Every scaffolded app comes with **all of this** out of the box:
+## How It Works
 
-- **Authentication** — Sign in, sign up, sign out, fully wired
-- **Forgot / Reset Password** — Complete recovery flow
-- **Protected Routes** — Middleware (Next.js) or route guards (React)
-- **Dashboard** — Sidebar navigation, responsive layout
-- **Settings** — Profile editing, avatar upload, password change
-- **Team Management** — Invite members, change roles, remove users
-- **API Keys** — Create apps, view and copy publishable/secret keys
-- **Email Verification** — Banner prompting unverified users
-- **Org Switcher** — Switch between organizations seamlessly
-- **Dark Theme** — Beautiful dark UI, responsive on all devices
+### Step 1 — Answer the prompts
 
-No glue code. No half-baked starters. A **complete application** from the first `npm run dev`.
+The CLI asks you a series of questions:
 
----
+```
+◆  Project name?
+│  my-saas-app
+│
+◆  Business name?
+│  Acme Corp
+│
+◆  Framework?
+│  ● Next.js 16 (App Router)
+│  ○ React 19 + Vite 7
+│
+◆  Language?
+│  ● TypeScript
+│  ○ JavaScript
+│
+◆  Package manager?
+│  ● npm
+│  ○ yarn
+│  ○ pnpm
+│  ○ bun
+│
+◆  GitHat publishable key?
+│  pk_live_abc123...
+│
+◆  Auth features to include?
+│  ◻ Forgot password
+│  ◻ Email verification
+│  ◻ Organization management
+│  ◻ MCP server identity
+│  ◻ AI agent identity
+│
+◆  Database?
+│  ● None
+│  ○ Prisma + PostgreSQL
+│  ○ Prisma + MySQL
+│  ○ Drizzle + PostgreSQL
+│  ○ Drizzle + SQLite
+│
+◆  Include Tailwind CSS 4?
+│  ● Yes  ○ No
+│
+◆  Include platform dashboard?
+│  ● Yes  ○ No
+│
+◆  Initialize git repository?
+│  ● Yes  ○ No
+│
+◆  Install dependencies now?
+│  ● Yes  ○ No
+```
 
-## Frameworks
+### Step 2 — Project is generated
 
-| Framework                | Router             | Styling               | Dev Server          |
-|--------------------------|--------------------|-----------------------|---------------------|
-| **Next.js** (App Router) | File-based routing | CSS Modules / globals | `next dev` on :3000 |
-| **React** (Vite)         | React Router DOM   | CSS / inline styles   | `vite` on :5173     |
+```
+◇  Project structure created
+◇  package.json generated
+◇  Git repository initialized
+◇  Dependencies installed
 
----
+◇  Setup complete!
+```
 
-## CLI Options & Flags
+### Step 3 — Start building
 
 ```bash
-npx create-githat-app [project-name] [options]
+cd my-saas-app
+npm run dev
 ```
 
-| Option                    | Description                                          |
-|---------------------------|------------------------------------------------------|
-| `project-name`            | Directory name for your app (prompted if omitted)    |
-| `--js`                    | Use JavaScript instead of TypeScript (Next.js only)  |
-| `--key <publishable_key>` | Set your GitHat publishable key upfront              |
+Your app is running at `http://localhost:3000` with auth, dashboard, and the full GitHat platform wired up.
 
-### Examples
+## CLI Flags
 
-```bash
-# Interactive — prompts for everything
-npx create-githat-app
+Skip prompts with flags:
 
-# Named project with defaults
-npx create-githat-app my-app
+```bash
+# Use JavaScript instead of TypeScript
+npx create-githat-app my-app --js
 
-# JavaScript project with key pre-configured
-npx create-githat-app my-app --js --key pk_live_abc123
-```
+# Use TypeScript (default)
+npx create-githat-app my-app --ts
 
----
+# Pass your publishable key directly
+npx create-githat-app my-app --key pk_live_abc123
 
-## Interactive Prompts
+# Combine flags
+npx create-githat-app my-app --js --key pk_live_abc123
 
-When you run the CLI, you'll be guided through:
+# Show help
+npx create-githat-app --help
 
-1. **Project name** — if not provided as an argument
-2. **Framework** — Next.js (App Router) or React (Vite)
-3. **Package manager** — npm, pnpm, or yarn
-4. **Publishable key** — optional; you can add it to `.env` later
-5. **Features** — multi-select the pages you want:
-   - Dashboard
-   - Settings (profile, avatar, password)
-   - Team management (invites, roles)
-   - Apps (API key management)
-   - Forgot Password (recovery flow)
+# Show version
+npx create-githat-app --version
+```
 
-Select only what you need, or grab them all.
+## What You Get
 
----
+A production-ready project connected to GitHat's hosted backend:
 
-## Project Structure
+- **Fully-managed backend** — `api.githat.io` handles auth, orgs, teams, API keys, agents, MCP
+- **Auth pages** — sign-in, sign-up, forgot password, email verification
+- **Protected dashboard** — sidebar navigation, org switcher, user button
+- **`@githat/nextjs` SDK** — `<GitHatProvider>`, `<ProtectedRoute>`, `useAuth()`
+- **`githat/` platform folder** — typed API client for all 42+ backend endpoints
+- **Dark theme** — zinc/purple design system out of the box
+- **Database ready** — Prisma or Drizzle for your app's own data (optional)
+- **Tailwind CSS 4** — utility-first styling (optional)
 
-### Next.js (App Router)
+## The `githat/` Folder
 
-```text
-my-app/
-├── app/
-│   ├── layout.tsx              # GitHatProvider wrapper
-│   ├── page.tsx                # Home with sign-in/up buttons
-│   ├── globals.css
-│   ├── middleware.ts           # Auth route protection
-│   ├── (auth)/
-│   │   ├── sign-in/page.tsx
-│   │   ├── sign-up/page.tsx
-│   │   ├── forgot-password/page.tsx
-│   │   └── reset-password/page.tsx
-│   └── dashboard/
-│       ├── layout.tsx          # Protected layout + sidebar
-│       ├── page.tsx
-│       ├── settings/page.tsx
-│       ├── team/page.tsx
-│       └── apps/page.tsx
-├── .env.local
-├── .env.example
-├── package.json
-└── next.config.mjs
-```
-
-### React (Vite)
-
-```text
-my-app/
-├── src/
-│   ├── main.jsx               # BrowserRouter + GitHatProvider
-│   ├── App.jsx                # Route definitions
-│   ├── pages/
-│   │   ├── Home.jsx
-│   │   ├── SignIn.jsx
-│   │   ├── SignUp.jsx
-│   │   ├── Dashboard.jsx
-│   │   ├── DashboardLayout.jsx
-│   │   ├── Settings.jsx
-│   │   ├── Team.jsx
-│   │   ├── Apps.jsx
-│   │   ├── ForgotPassword.jsx
-│   │   └── ResetPassword.jsx
-│   └── components/
-│       ├── Sidebar.jsx
-│       └── VerifyEmailBanner.jsx
-├── .env
-├── .env.example
-├── index.html
-└── vite.config.js
-```
-
----
-
-## Configuration
-
-After scaffolding, add your GitHat publishable key to the environment file:
-
-**Next.js** — `.env.local`
+Your generated project includes a `githat/` directory — a local integration layer between your app and the GitHat platform API:
 
-```env
-NEXT_PUBLIC_GITHAT_PUBLISHABLE_KEY=pk_live_your_key_here
+```
+githat/
+  config.ts              # Central configuration (env vars, feature flags)
+  api/
+    client.ts            # Typed fetch wrapper with token refresh
+    types.ts             # TypeScript interfaces for all API responses
+    auth.ts              # Login, register, forgot password, verify email
+    orgs.ts              # Create/update orgs, invite/remove members
+    users.ts             # List orgs, switch org
+    mcp.ts               # Register/verify MCP servers
+    agents.ts            # Register/verify AI agent wallets
+  auth/
+    guard.tsx            # Role-based route protection component
+    index.ts             # Auth exports
+  dashboard/
+    layout.tsx           # Dashboard shell with sidebar navigation
+    overview.tsx         # Stats overview page
+    apps.tsx             # App + API key management
+    members.tsx          # Invite members, manage roles, remove
+    settings.tsx         # Edit org name, brand color, save
+    mcp-servers.tsx      # Register MCP servers, verify, remove
+    agents.tsx           # Register AI agent wallets, verify, remove
 ```
 
-**React (Vite)** — `.env`
+All API calls go to `api.githat.io`. The client handles auth tokens and automatic refresh.
 
-```env
-VITE_GITHAT_PUBLISHABLE_KEY=pk_live_your_key_here
-```
+## Your Backend is GitHat
 
-If you passed `--key pk_live_xxx` during setup, this is already configured for you.
+You don't deploy or maintain a backend. GitHat's hosted platform handles:
 
-> A `.env.example` file is included in every project for reference.
+- **Authentication** — sign-up, sign-in, email verification, password reset
+- **Organizations** — create, switch, branding, custom domains
+- **Team management** — invite members by email, assign roles (owner/admin/member), remove
+- **API key management** — publishable + secret keys per app, rotation
+- **MCP server registration** — domain verification via DNS TXT, OAuth2 credentials
+- **AI agent registration** — Ethereum wallet verification, challenge-response tokens
+- **Email delivery** — verification emails, invitations, password resets (via AWS SES)
+- **Database** — users, orgs, teams, apps, agents, MCP servers (DynamoDB, managed by GitHat)
+- **Public verification** — anyone can verify an agent or MCP server at `githat.io/verify/`
 
----
+Your data lives in GitHat's infrastructure. You write frontend code, GitHat handles the rest.
 
-## Getting Your Publishable Key
+## Three Identity Types
 
-1. Go to [https://githat.io](https://githat.io) and create an account
-2. Create an organization (or use your default one)
-3. Navigate to **Apps** in the dashboard
-4. Create a new app and copy the **Publishable Key**
-5. Paste it into your `.env.local` or `.env` file
+GitHat supports three types of identity in a single platform:
 
----
+| Type            | Auth Method                | Dashboard Page |
+| --------------- | -------------------------- | -------------- |
+| **Humans**      | Email + password           | Members        |
+| **MCP Servers** | Domain verification        | MCP Servers    |
+| **AI Agents**   | Ethereum wallet signatures | AI Agents      |
+
+## Project Structure
 
-## Dependencies
+### Next.js 16
 
-The CLI installs only what your chosen framework needs:
+```
+my-app/
+  app/
+    layout.tsx
+    page.tsx
+    globals.css
+    (auth)/
+      sign-in/page.tsx
+      sign-up/page.tsx
+      forgot-password/page.tsx
+      verify-email/page.tsx
+    dashboard/
+      layout.tsx
+      page.tsx
+      apps/page.tsx
+      members/page.tsx
+      settings/page.tsx
+      mcp/page.tsx
+      agents/page.tsx
+  githat/
+    ...
+  middleware.ts
+  next.config.ts
+  .env.local
+```
 
-**Next.js projects:**
+### React 19 + Vite 7
 
-- `@githat/nextjs` — GitHat SDK (auth provider, components, hooks)
-- `next` — Next.js framework
-- `react` / `react-dom` — React
+```
+my-app/
+  src/
+    main.tsx
+    App.tsx
+    index.css
+    pages/
+      Home.tsx
+      SignIn.tsx
+      SignUp.tsx
+      ForgotPassword.tsx
+      VerifyEmail.tsx
+      Dashboard.tsx
+  githat/
+    ...
+  index.html
+  vite.config.ts
+  .env.local
+```
 
-**React (Vite) projects:**
+## Environment Variables
 
-- `@githat/nextjs` — GitHat SDK (works with any React setup)
-- `react` / `react-dom` — React
-- `react-router-dom` — Client-side routing
-- `vite` / `@vitejs/plugin-react` — Build tooling
+Generated `.env.local`:
 
----
+```env
+# Next.js
+NEXT_PUBLIC_GITHAT_PUBLISHABLE_KEY=pk_live_...
+NEXT_PUBLIC_GITHAT_API_URL=https://api.githat.io
 
-## Links
+# React/Vite
+VITE_GITHAT_PUBLISHABLE_KEY=pk_live_...
+VITE_GITHAT_API_URL=https://api.githat.io
+```
 
-- **GitHat Platform** — [https://githat.io](https://githat.io)
-- **SDK Documentation** — [@githat/nextjs on npm](https://www.npmjs.com/package/@githat/nextjs)
-- **CLI on npm** — [create-githat-app](https://www.npmjs.com/package/create-githat-app)
-- **GitHub** — [GitHat-IO/create-githat-app](https://github.com/GitHat-IO/create-githat-app)
-- **Report Issues** — [GitHub Issues](https://github.com/GitHat-IO/create-githat-app/issues)
+## Contributing
 
----
+```bash
+git clone https://github.com/GitHat-IO/create-githat-app.git
+cd create-githat-app
+npm install
+npm run build
+node bin/index.js test-app
+```
 
 ## License
 
-Proprietary — see [LICENSE](../../LICENSE) for details.
+MIT

package/bin/index.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 
-const { cli } = require('../src/cli');
-cli(process.argv.slice(2)).catch((err) => {
-  console.error(err.message);
+import('../dist/cli.js').catch((err) => {
+  console.error(err.message || err);
   process.exit(1);
 });