create-githat-app 1.0.9 → 1.0.11

package/README.md

@@ -14,9 +14,9 @@
 
 ---
 
-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.**
+Scaffold a production-ready app with a fully-managed backend — auth, teams, orgs, API keys, and AI agent identity. **No backend to deploy.**
 
-[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.
+[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, and AI agents are all stored and managed by GitHat. You write frontend code only.
 
 ## Install & Launch
 
@@ -75,7 +75,6 @@ The CLI asks you a series of questions:
 │  ◻ Forgot password
 │  ◻ Email verification
 │  ◻ Organization management
-│  ◻ MCP server identity
 │  ◻ AI agent identity
 │
 ◆  Database?
@@ -146,11 +145,11 @@ npx create-githat-app --version
 
 A production-ready project connected to GitHat's hosted backend:
 
-- **Fully-managed backend** — `api.githat.io` handles auth, orgs, teams, API keys, agents, MCP
+- **Fully-managed backend** — `api.githat.io` handles auth, orgs, teams, API keys, and agents
 - **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
+- **`githat/` platform folder** — typed API client for the full REST API
 - **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)
@@ -168,7 +167,6 @@ githat/
     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
@@ -179,7 +177,6 @@ githat/
     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
 ```
 
@@ -193,23 +190,21 @@ You don't deploy or maintain a backend. GitHat's hosted platform handles:
 - **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/`
+- **Database** — users, orgs, teams, apps, and agents (DynamoDB, managed by GitHat)
+- **Public verification** — anyone can verify an agent at `githat.io/verify/`
 
 Your data lives in GitHat's infrastructure. You write frontend code, GitHat handles the rest.
 
-## Three Identity Types
+## Two Identity Types
 
-GitHat supports three types of identity in a single platform:
+GitHat supports two 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      |
+| Type          | Auth Method                | Dashboard Page |
+| ------------- | -------------------------- | -------------- |
+| **Humans**    | Email + password           | Members        |
+| **AI Agents** | Ethereum wallet signatures | AI Agents      |
 
 ## Project Structure
 
@@ -281,7 +276,7 @@ VITE_GITHAT_API_URL=https://api.githat.io
 
 - [GitHat Quick Start](https://githat.io/docs/quickstart) — Get running in 5 minutes
 - [SDK Reference](https://githat.io/docs/sdk) — `@githat/nextjs` hooks, components, and server utils
-- [API Reference](https://githat.io/docs/api) — All 86 REST endpoints
+- [API Reference](https://githat.io/docs/api) — Full REST API reference
 - [CLI Reference](https://githat.io/docs/cli) — Flags, prompts, and templates
 - [Next.js Guide](https://githat.io/docs/nextjs) — Auth in Next.js 14-16+
 - [React Guide](https://githat.io/docs/react) — Auth in any React app

package/dist/cli.js

@@ -2,8 +2,8 @@ import { createRequire } from 'module'; const require = createRequire(import.met
 
 // src/cli.ts
 import { Command as Command7 } from "commander";
-import * as p11 from "@clack/prompts";
-import chalk9 from "chalk";
+import * as p12 from "@clack/prompts";
+import chalk10 from "chalk";
 
 // src/utils/ascii.ts
 import figlet from "figlet";
@@ -11,7 +11,7 @@ import gradient from "gradient-string";
 import chalk from "chalk";
 
 // src/constants.ts
-var VERSION = "1.0.9";
+var VERSION = "1.0.11";
 var DEFAULT_API_URL = "https://api.githat.io";
 var DASHBOARD_URL = "https://githat.io/dashboard/apps";
 var BRAND_COLORS = ["#7c3aed", "#6366f1", "#8b5cf6"];
@@ -21,7 +21,7 @@ var DEPS = {
       next: "^16.0.0",
       react: "^19.0.0",
       "react-dom": "^19.0.0",
-      "@githat/nextjs": "^0.2.4"
+      "@githat/nextjs": "^0.5.0"
     },
     devDependencies: {
       typescript: "^5.9.0",
@@ -35,7 +35,7 @@ var DEPS = {
       react: "^19.0.0",
       "react-dom": "^19.0.0",
       "react-router-dom": "^7.0.0",
-      "@githat/nextjs": "^0.2.4"
+      "@githat/nextjs": "^0.5.0"
     },
     devDependencies: {
       vite: "^7.0.0",
@@ -657,11 +657,11 @@ function answersToContext(answers) {
 }
 
 // src/scaffold/index.ts
-import fs3 from "fs-extra";
-import path3 from "path";
+import fs4 from "fs-extra";
+import path4 from "path";
 import { execSync as execSync3 } from "child_process";
-import * as p9 from "@clack/prompts";
-import chalk2 from "chalk";
+import * as p10 from "@clack/prompts";
+import chalk3 from "chalk";
 
 // src/utils/template-engine.ts
 import Handlebars from "handlebars";
@@ -809,27 +809,109 @@ function initGit(cwd) {
   }
 }
 
+// src/utils/register-app.ts
+import fs3 from "fs-extra";
+import path3 from "path";
+import os from "os";
+import * as p9 from "@clack/prompts";
+import chalk2 from "chalk";
+var CREDENTIALS_PATH = path3.join(os.homedir(), ".githat", "credentials.json");
+function readToken() {
+  if (!fs3.existsSync(CREDENTIALS_PATH)) {
+    return null;
+  }
+  try {
+    const creds = fs3.readJsonSync(CREDENTIALS_PATH);
+    return creds.token || null;
+  } catch {
+    return null;
+  }
+}
+async function registerApp(appName, projectRoot) {
+  const token = readToken();
+  if (!token) {
+    p9.log.warn(
+      chalk2.yellow(
+        `GitHat credentials not found at ${CREDENTIALS_PATH}.
+  Run ${chalk2.cyan("githat login")} then re-run scaffolding, or paste your publishable key
+  from ${chalk2.cyan("https://githat.io/dashboard/apps")} into .env.local manually.`
+      )
+    );
+    return null;
+  }
+  p9.log.step("Registering app on GitHat...");
+  let registeredApp;
+  try {
+    const response = await fetch(`${DEFAULT_API_URL}/apps`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify({
+        name: appName,
+        redirect_uris: ["http://localhost:3000/callback"]
+      })
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new Error(`HTTP ${response.status}: ${body}`);
+    }
+    registeredApp = await response.json();
+  } catch (err) {
+    p9.log.warn(
+      chalk2.yellow(
+        `Could not register app on GitHat: ${err.message}
+  The scaffold was written successfully. Once the API is available,
+  register manually at ${chalk2.cyan("https://githat.io/dashboard/apps")} and paste the
+  publishable key into ${chalk2.cyan(".env.local")}.`
+      )
+    );
+    return null;
+  }
+  const publishableKey = registeredApp.publishable_key;
+  const envLocalPath = path3.join(projectRoot, ".env.local");
+  try {
+    let envContent = fs3.existsSync(envLocalPath) ? fs3.readFileSync(envLocalPath, "utf-8") : "";
+    const keyLine = `NEXT_PUBLIC_GITHAT_PUBLISHABLE_KEY=${publishableKey}`;
+    if (envContent.includes("NEXT_PUBLIC_GITHAT_PUBLISHABLE_KEY=")) {
+      envContent = envContent.replace(
+        /NEXT_PUBLIC_GITHAT_PUBLISHABLE_KEY=.*/,
+        keyLine
+      );
+    } else {
+      envContent += (envContent.endsWith("\n") || envContent === "" ? "" : "\n") + keyLine + "\n";
+    }
+    fs3.ensureDirSync(path3.dirname(envLocalPath));
+    fs3.writeFileSync(envLocalPath, envContent, "utf-8");
+  } catch (err) {
+    p9.log.warn(chalk2.yellow(`Registered app but could not write .env.local: ${err.message}`));
+  }
+  p9.log.success(chalk2.green(`Registered "${appName}" on GitHat. Publishable key written to .env.local.`));
+  return publishableKey;
+}
+
 // src/scaffold/index.ts
 async function scaffold(context, options) {
-  const root = path3.resolve(process.cwd(), context.projectName);
-  if (fs3.existsSync(root)) {
-    p9.cancel(`Directory "${context.projectName}" already exists.`);
+  const root = path4.resolve(process.cwd(), context.projectName);
+  if (fs4.existsSync(root)) {
+    p10.cancel(`Directory "${context.projectName}" already exists.`);
     process.exit(1);
   }
   const isFullstack = context.projectType === "fullstack";
   await withSpinner("Creating project structure...", async () => {
-    fs3.ensureDirSync(root);
+    fs4.ensureDirSync(root);
     const templatesRoot = getTemplatesRoot();
     if (isFullstack) {
       scaffoldFullstack(templatesRoot, root, context);
     } else {
-      const frameworkDir = path3.join(templatesRoot, context.framework);
-      if (!fs3.existsSync(frameworkDir)) {
+      const frameworkDir = path4.join(templatesRoot, context.framework);
+      if (!fs4.existsSync(frameworkDir)) {
         throw new Error(`Templates not found at ${frameworkDir}. This is a bug \u2014 please report it.`);
       }
       renderTemplateDirectory(frameworkDir, root, context);
-      const baseDir = path3.join(templatesRoot, "base");
-      if (fs3.existsSync(baseDir)) {
+      const baseDir = path4.join(templatesRoot, "base");
+      if (fs4.existsSync(baseDir)) {
         renderTemplateDirectory(baseDir, root, context);
       }
     }
@@ -840,6 +922,9 @@ async function scaffold(context, options) {
       writeJson(root, "package.json", pkg);
     }, "package.json generated");
   }
+  if (!isFullstack && context.framework === "nextjs") {
+    await registerApp(context.projectName, root);
+  }
   if (options.initGit) {
     const gitSpinner = createSpinner("Initializing git repository...");
     gitSpinner.start();
@@ -860,69 +945,69 @@ async function scaffold(context, options) {
         } catch (err) {
           const msg = err.message || "";
           if (msg.includes("TIMEOUT")) {
-            p9.log.warn(`Install timed out. Run ${chalk2.cyan(installCmd)} manually.`);
+            p10.log.warn(`Install timed out. Run ${chalk3.cyan(installCmd)} manually.`);
           } else {
-            p9.log.warn(`Could not auto-install. Run ${chalk2.cyan(installCmd)} manually.`);
+            p10.log.warn(`Could not auto-install. Run ${chalk3.cyan(installCmd)} manually.`);
           }
         }
       },
       "Dependencies installed"
     );
   }
-  p9.outro("Setup complete!");
+  p10.outro("Setup complete!");
   displaySuccess(context.projectName, context.packageManager, context.framework, !!context.publishableKey, isFullstack);
   if (!options.skipPrompts) {
-    const starPrompt = await p9.confirm({
+    const starPrompt = await p10.confirm({
       message: "Star GitHat on GitHub? (helps us grow!)",
       initialValue: false
     });
-    if (!p9.isCancel(starPrompt) && starPrompt) {
+    if (!p10.isCancel(starPrompt) && starPrompt) {
       try {
         const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
         execSync3(`${cmd} "https://github.com/GitHat-IO/githat"`, { stdio: "ignore" });
       } catch {
-        p9.log.info("Visit https://github.com/GitHat-IO/githat to star us!");
+        p10.log.info("Visit https://github.com/GitHat-IO/githat to star us!");
       }
     }
   }
 }
 function scaffoldFullstack(templatesRoot, root, context) {
-  const fullstackDir = path3.join(templatesRoot, "fullstack");
-  const rootDir = path3.join(fullstackDir, "root");
-  if (fs3.existsSync(rootDir)) {
+  const fullstackDir = path4.join(templatesRoot, "fullstack");
+  const rootDir = path4.join(fullstackDir, "root");
+  if (fs4.existsSync(rootDir)) {
     renderTemplateDirectory(rootDir, root, context);
   }
-  const appsDir = path3.join(root, "apps");
-  fs3.ensureDirSync(appsDir);
-  const webDir = path3.join(appsDir, "web");
-  fs3.ensureDirSync(webDir);
-  const webTemplateDir = path3.join(fullstackDir, `apps-web-${context.framework}`);
-  if (fs3.existsSync(webTemplateDir)) {
+  const appsDir = path4.join(root, "apps");
+  fs4.ensureDirSync(appsDir);
+  const webDir = path4.join(appsDir, "web");
+  fs4.ensureDirSync(webDir);
+  const webTemplateDir = path4.join(fullstackDir, `apps-web-${context.framework}`);
+  if (fs4.existsSync(webTemplateDir)) {
     renderTemplateDirectory(webTemplateDir, webDir, context);
   } else {
     throw new Error(`Web app templates not found at ${webTemplateDir}. This is a bug \u2014 please report it.`);
   }
-  const apiDir = path3.join(appsDir, "api");
-  fs3.ensureDirSync(apiDir);
+  const apiDir = path4.join(appsDir, "api");
+  fs4.ensureDirSync(apiDir);
   const backendFramework = context.backendFramework || "hono";
-  const apiTemplateDir = path3.join(fullstackDir, `apps-api-${backendFramework}`);
-  if (fs3.existsSync(apiTemplateDir)) {
+  const apiTemplateDir = path4.join(fullstackDir, `apps-api-${backendFramework}`);
+  if (fs4.existsSync(apiTemplateDir)) {
     renderTemplateDirectory(apiTemplateDir, apiDir, context);
   } else {
     throw new Error(`API templates not found at ${apiTemplateDir}. This is a bug \u2014 please report it.`);
   }
-  const packagesDir = path3.join(root, "packages");
-  fs3.ensureDirSync(packagesDir);
-  fs3.writeFileSync(path3.join(packagesDir, ".gitkeep"), "");
+  const packagesDir = path4.join(root, "packages");
+  fs4.ensureDirSync(packagesDir);
+  fs4.writeFileSync(path4.join(packagesDir, ".gitkeep"), "");
 }
 
 // src/commands/skills/index.ts
 import { Command as Command6 } from "commander";
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 
 // src/commands/skills/search.ts
 import { Command } from "commander";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 
 // src/commands/skills/api.ts
 async function fetchApi(endpoint, options = {}) {
@@ -970,99 +1055,99 @@ async function getDownloadUrl(slug, version) {
 // src/commands/skills/search.ts
 function formatSkill(skill) {
   const typeColors = {
-    template: chalk3.blue,
-    integration: chalk3.green,
-    ui: chalk3.magenta,
-    ai: chalk3.yellow,
-    workflow: chalk3.cyan
+    template: chalk4.blue,
+    integration: chalk4.green,
+    ui: chalk4.magenta,
+    ai: chalk4.yellow,
+    workflow: chalk4.cyan
   };
-  const typeColor = typeColors[skill.type] || chalk3.white;
+  const typeColor = typeColors[skill.type] || chalk4.white;
   return [
-    `${chalk3.bold(skill.name)} ${chalk3.dim(`@${skill.latestVersion}`)}`,
+    `${chalk4.bold(skill.name)} ${chalk4.dim(`@${skill.latestVersion}`)}`,
     `  ${skill.description}`,
     `  ${typeColor(skill.type)} \xB7 \u2B07 ${skill.downloads} \xB7 \u2B50 ${skill.stars} \xB7 by ${skill.authorName}`,
-    `  ${chalk3.dim(`githat skills install ${skill.slug}`)}`
+    `  ${chalk4.dim(`githat skills install ${skill.slug}`)}`
   ].join("\n");
 }
 var searchCommand = new Command("search").description("Search skills by keyword").argument("<query>", "Search query").option("-t, --type <type>", "Filter by type (template, integration, ui, ai, workflow)").action(async (query, options) => {
   try {
-    console.log(chalk3.dim(`
+    console.log(chalk4.dim(`
 Searching for "${query}"...
 `));
     const result = await searchSkills(query, options.type);
     if (result.skills.length === 0) {
-      console.log(chalk3.yellow("No skills found matching your query."));
-      console.log(chalk3.dim("\nTry a different search term or browse all skills:"));
-      console.log(chalk3.dim("  githat skills list"));
+      console.log(chalk4.yellow("No skills found matching your query."));
+      console.log(chalk4.dim("\nTry a different search term or browse all skills:"));
+      console.log(chalk4.dim("  githat skills list"));
       return;
     }
-    console.log(chalk3.cyan(`Found ${result.skills.length} skill(s):
+    console.log(chalk4.cyan(`Found ${result.skills.length} skill(s):
 `));
     for (const skill of result.skills) {
       console.log(formatSkill(skill));
       console.log("");
     }
   } catch (err) {
-    console.error(chalk3.red(`Error: ${err.message}`));
+    console.error(chalk4.red(`Error: ${err.message}`));
     process.exit(1);
   }
 });
 
 // src/commands/skills/list.ts
 import { Command as Command2 } from "commander";
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 function formatSkillCompact(skill) {
   const typeColors = {
-    template: chalk4.blue,
-    integration: chalk4.green,
-    ui: chalk4.magenta,
-    ai: chalk4.yellow,
-    workflow: chalk4.cyan
+    template: chalk5.blue,
+    integration: chalk5.green,
+    ui: chalk5.magenta,
+    ai: chalk5.yellow,
+    workflow: chalk5.cyan
   };
-  const typeColor = typeColors[skill.type] || chalk4.white;
-  const name = chalk4.bold(skill.name.padEnd(25));
+  const typeColor = typeColors[skill.type] || chalk5.white;
+  const name = chalk5.bold(skill.name.padEnd(25));
   const type = typeColor(skill.type.padEnd(12));
   const stats = `\u2B07 ${String(skill.downloads).padStart(5)} \u2B50 ${String(skill.stars).padStart(4)}`;
   const desc = skill.description.length > 40 ? skill.description.substring(0, 37) + "..." : skill.description;
-  return `${name} ${type} ${stats}  ${chalk4.dim(desc)}`;
+  return `${name} ${type} ${stats}  ${chalk5.dim(desc)}`;
 }
 var listCommand = new Command2("list").description("List available skills").option("-t, --type <type>", "Filter by type (template, integration, ui, ai, workflow)").option("-l, --limit <n>", "Number of results (default: 25)", "25").action(async (options) => {
   try {
     const limit = parseInt(options.limit, 10);
-    console.log(chalk4.dim("\nFetching skills...\n"));
+    console.log(chalk5.dim("\nFetching skills...\n"));
     const result = await listSkills({ type: options.type, limit });
     if (result.skills.length === 0) {
-      console.log(chalk4.yellow("No skills found."));
+      console.log(chalk5.yellow("No skills found."));
       if (options.type) {
-        console.log(chalk4.dim(`
+        console.log(chalk5.dim(`
 Try without the type filter:`));
-        console.log(chalk4.dim("  githat skills list"));
+        console.log(chalk5.dim("  githat skills list"));
       }
       return;
     }
     const header = `${"NAME".padEnd(25)} ${"TYPE".padEnd(12)} ${"DOWNLOADS".padStart(10)}  DESCRIPTION`;
-    console.log(chalk4.dim(header));
-    console.log(chalk4.dim("\u2500".repeat(80)));
+    console.log(chalk5.dim(header));
+    console.log(chalk5.dim("\u2500".repeat(80)));
     for (const skill of result.skills) {
       console.log(formatSkillCompact(skill));
     }
-    console.log(chalk4.dim("\u2500".repeat(80)));
-    console.log(chalk4.dim(`Showing ${result.skills.length} skill(s)`));
+    console.log(chalk5.dim("\u2500".repeat(80)));
+    console.log(chalk5.dim(`Showing ${result.skills.length} skill(s)`));
     if (result.nextCursor) {
-      console.log(chalk4.dim("\nMore results available. Use --limit to see more."));
+      console.log(chalk5.dim("\nMore results available. Use --limit to see more."));
     }
-    console.log(chalk4.dim("\nTo install: githat skills install <name>"));
+    console.log(chalk5.dim("\nTo install: githat skills install <name>"));
   } catch (err) {
-    console.error(chalk4.red(`Error: ${err.message}`));
+    console.error(chalk5.red(`Error: ${err.message}`));
     process.exit(1);
   }
 });
 
 // src/commands/skills/install.ts
 import { Command as Command3 } from "commander";
-import chalk5 from "chalk";
-import * as fs4 from "fs";
-import * as path4 from "path";
+import chalk6 from "chalk";
+import * as fs5 from "fs";
+import * as path5 from "path";
 import { pipeline } from "stream/promises";
 import { createWriteStream, mkdirSync } from "fs";
 import { Extract } from "unzipper";
@@ -1071,20 +1156,20 @@ async function downloadAndExtract(url, destDir) {
   if (!response.ok) {
     throw new Error(`Download failed: ${response.statusText}`);
   }
-  const tempZip = path4.join(destDir, ".skill-download.zip");
+  const tempZip = path5.join(destDir, ".skill-download.zip");
   const fileStream = createWriteStream(tempZip);
   await pipeline(response.body, fileStream);
   await new Promise((resolve4, reject) => {
-    fs4.createReadStream(tempZip).pipe(Extract({ path: destDir })).on("close", resolve4).on("error", reject);
+    fs5.createReadStream(tempZip).pipe(Extract({ path: destDir })).on("close", resolve4).on("error", reject);
   });
-  fs4.unlinkSync(tempZip);
+  fs5.unlinkSync(tempZip);
 }
 function updateGithatLock(projectDir, skill) {
-  const lockPath = path4.join(projectDir, "githat.lock");
+  const lockPath = path5.join(projectDir, "githat.lock");
   let lock = {};
-  if (fs4.existsSync(lockPath)) {
+  if (fs5.existsSync(lockPath)) {
     try {
-      lock = JSON.parse(fs4.readFileSync(lockPath, "utf-8"));
+      lock = JSON.parse(fs5.readFileSync(lockPath, "utf-8"));
     } catch {
     }
   }
@@ -1092,17 +1177,17 @@ function updateGithatLock(projectDir, skill) {
     version: skill.version,
     installedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  fs4.writeFileSync(lockPath, JSON.stringify(lock, null, 2));
+  fs5.writeFileSync(lockPath, JSON.stringify(lock, null, 2));
 }
 function updateEnvExample(projectDir, manifest) {
   if (!manifest.requires?.env?.length) return;
-  const envPath = path4.join(projectDir, ".env.local");
-  const envExamplePath = path4.join(projectDir, ".env.example");
+  const envPath = path5.join(projectDir, ".env.local");
+  const envExamplePath = path5.join(projectDir, ".env.example");
   let envContent = "";
-  if (fs4.existsSync(envPath)) {
-    envContent = fs4.readFileSync(envPath, "utf-8");
-  } else if (fs4.existsSync(envExamplePath)) {
-    envContent = fs4.readFileSync(envExamplePath, "utf-8");
+  if (fs5.existsSync(envPath)) {
+    envContent = fs5.readFileSync(envPath, "utf-8");
+  } else if (fs5.existsSync(envExamplePath)) {
+    envContent = fs5.readFileSync(envExamplePath, "utf-8");
   }
   const existingVars = new Set(
     envContent.split("\n").filter((line) => line.includes("=")).map((line) => line.split("=")[0].trim())
@@ -1118,10 +1203,10 @@ function updateEnvExample(projectDir, manifest) {
 # Added by skill install
 ${newVars.join("\n")}
 `;
-    if (fs4.existsSync(envPath)) {
-      fs4.appendFileSync(envPath, addition);
+    if (fs5.existsSync(envPath)) {
+      fs5.appendFileSync(envPath, addition);
     } else {
-      fs4.writeFileSync(envPath, `# Environment variables
+      fs5.writeFileSync(envPath, `# Environment variables
 ${newVars.join("\n")}
 `);
     }
@@ -1129,112 +1214,112 @@ ${newVars.join("\n")}
 }
 var installCommand = new Command3("install").description("Install a skill to your project").argument("<slug>", "Skill slug (e.g., stripe-billing)").option("-v, --version <version>", "Specific version to install").option("-d, --dir <dir>", "Project directory (default: current directory)").action(async (slug, options) => {
   try {
-    const projectDir = options.dir ? path4.resolve(options.dir) : process.cwd();
-    const packageJsonPath = path4.join(projectDir, "package.json");
-    if (!fs4.existsSync(packageJsonPath)) {
-      console.error(chalk5.red("Error: No package.json found. Are you in a project directory?"));
+    const projectDir = options.dir ? path5.resolve(options.dir) : process.cwd();
+    const packageJsonPath = path5.join(projectDir, "package.json");
+    if (!fs5.existsSync(packageJsonPath)) {
+      console.error(chalk6.red("Error: No package.json found. Are you in a project directory?"));
       process.exit(1);
     }
-    console.log(chalk5.dim(`
+    console.log(chalk6.dim(`
 Fetching skill info for "${slug}"...
 `));
     const skill = await getSkill(slug);
-    console.log(chalk5.cyan(`\u{1F4E6} ${skill.name}`));
-    console.log(chalk5.dim(`   ${skill.description}`));
-    console.log(chalk5.dim(`   Type: ${skill.type} \xB7 Author: ${skill.authorName}
+    console.log(chalk6.cyan(`\u{1F4E6} ${skill.name}`));
+    console.log(chalk6.dim(`   ${skill.description}`));
+    console.log(chalk6.dim(`   Type: ${skill.type} \xB7 Author: ${skill.authorName}
 `));
     const download = await getDownloadUrl(slug, options.version);
     const version = download.version.version;
-    console.log(chalk5.dim(`Downloading ${skill.name}@${version}...`));
-    const skillDir = path4.join(projectDir, "githat", "skills", slug);
+    console.log(chalk6.dim(`Downloading ${skill.name}@${version}...`));
+    const skillDir = path5.join(projectDir, "githat", "skills", slug);
     mkdirSync(skillDir, { recursive: true });
     await downloadAndExtract(download.downloadUrl, skillDir);
-    console.log(chalk5.green(`\u2713 Downloaded to ${path4.relative(projectDir, skillDir)}`));
-    const manifestPath = path4.join(skillDir, "githat-skill.json");
-    if (fs4.existsSync(manifestPath)) {
-      const manifest = JSON.parse(fs4.readFileSync(manifestPath, "utf-8"));
+    console.log(chalk6.green(`\u2713 Downloaded to ${path5.relative(projectDir, skillDir)}`));
+    const manifestPath = path5.join(skillDir, "githat-skill.json");
+    if (fs5.existsSync(manifestPath)) {
+      const manifest = JSON.parse(fs5.readFileSync(manifestPath, "utf-8"));
       updateEnvExample(projectDir, manifest);
       if (manifest.requires?.env?.length) {
-        console.log(chalk5.yellow(`
+        console.log(chalk6.yellow(`
 \u26A0 Required environment variables:`));
         for (const envVar of manifest.requires.env) {
-          console.log(chalk5.dim(`   ${envVar}`));
+          console.log(chalk6.dim(`   ${envVar}`));
         }
-        console.log(chalk5.dim(`
+        console.log(chalk6.dim(`
    Add these to your .env.local file`));
       }
       if (manifest.install?.dependencies) {
         const deps = Object.entries(manifest.install.dependencies).map(([name, ver]) => `${name}@${ver}`).join(" ");
-        console.log(chalk5.yellow(`
+        console.log(chalk6.yellow(`
 \u26A0 Install npm dependencies:`));
-        console.log(chalk5.dim(`   npm install ${deps}`));
+        console.log(chalk6.dim(`   npm install ${deps}`));
       }
     }
     updateGithatLock(projectDir, { slug, version });
-    console.log(chalk5.green(`
+    console.log(chalk6.green(`
 \u2705 Successfully installed ${skill.name}@${version}
 `));
-    console.log(chalk5.dim("Next steps:"));
-    console.log(chalk5.dim(`  1. Check githat/skills/${slug}/README.md for usage`));
-    console.log(chalk5.dim("  2. Add required environment variables to .env.local"));
-    console.log(chalk5.dim("  3. Import and use the skill in your code"));
+    console.log(chalk6.dim("Next steps:"));
+    console.log(chalk6.dim(`  1. Check githat/skills/${slug}/README.md for usage`));
+    console.log(chalk6.dim("  2. Add required environment variables to .env.local"));
+    console.log(chalk6.dim("  3. Import and use the skill in your code"));
   } catch (err) {
-    console.error(chalk5.red(`Error: ${err.message}`));
+    console.error(chalk6.red(`Error: ${err.message}`));
     process.exit(1);
   }
 });
 
 // src/commands/skills/installed.ts
 import { Command as Command4 } from "commander";
-import chalk6 from "chalk";
-import * as fs5 from "fs";
-import * as path5 from "path";
+import chalk7 from "chalk";
+import * as fs6 from "fs";
+import * as path6 from "path";
 var installedCommand = new Command4("installed").alias("ls").description("List installed skills in current project").option("-d, --dir <dir>", "Project directory (default: current directory)").action(async (options) => {
   try {
-    const projectDir = options.dir ? path5.resolve(options.dir) : process.cwd();
-    const lockPath = path5.join(projectDir, "githat.lock");
-    if (!fs5.existsSync(lockPath)) {
-      console.log(chalk6.yellow("\nNo skills installed in this project."));
-      console.log(chalk6.dim("\nTo install a skill:"));
-      console.log(chalk6.dim("  githat skills install <slug>"));
+    const projectDir = options.dir ? path6.resolve(options.dir) : process.cwd();
+    const lockPath = path6.join(projectDir, "githat.lock");
+    if (!fs6.existsSync(lockPath)) {
+      console.log(chalk7.yellow("\nNo skills installed in this project."));
+      console.log(chalk7.dim("\nTo install a skill:"));
+      console.log(chalk7.dim("  githat skills install <slug>"));
       return;
     }
     let lock;
     try {
-      lock = JSON.parse(fs5.readFileSync(lockPath, "utf-8"));
+      lock = JSON.parse(fs6.readFileSync(lockPath, "utf-8"));
     } catch {
-      console.error(chalk6.red("Error: Invalid githat.lock file"));
+      console.error(chalk7.red("Error: Invalid githat.lock file"));
       process.exit(1);
     }
     const entries = Object.entries(lock);
     if (entries.length === 0) {
-      console.log(chalk6.yellow("\nNo skills installed in this project."));
+      console.log(chalk7.yellow("\nNo skills installed in this project."));
       return;
     }
-    console.log(chalk6.cyan(`
+    console.log(chalk7.cyan(`
 \u{1F4E6} Installed skills (${entries.length}):
 `));
-    console.log(chalk6.dim(`${"SKILL".padEnd(30)} ${"VERSION".padEnd(12)} INSTALLED`));
-    console.log(chalk6.dim("\u2500".repeat(60)));
+    console.log(chalk7.dim(`${"SKILL".padEnd(30)} ${"VERSION".padEnd(12)} INSTALLED`));
+    console.log(chalk7.dim("\u2500".repeat(60)));
     for (const [slug, entry] of entries) {
       const date = new Date(entry.installedAt).toLocaleDateString();
-      console.log(`${chalk6.bold(slug.padEnd(30))} ${entry.version.padEnd(12)} ${chalk6.dim(date)}`);
+      console.log(`${chalk7.bold(slug.padEnd(30))} ${entry.version.padEnd(12)} ${chalk7.dim(date)}`);
     }
-    console.log(chalk6.dim("\u2500".repeat(60)));
-    console.log(chalk6.dim("\nTo update a skill:"));
-    console.log(chalk6.dim("  githat skills install <slug> --version <new-version>"));
+    console.log(chalk7.dim("\u2500".repeat(60)));
+    console.log(chalk7.dim("\nTo update a skill:"));
+    console.log(chalk7.dim("  githat skills install <slug> --version <new-version>"));
   } catch (err) {
-    console.error(chalk6.red(`Error: ${err.message}`));
+    console.error(chalk7.red(`Error: ${err.message}`));
     process.exit(1);
   }
 });
 
 // src/commands/skills/init.ts
 import { Command as Command5 } from "commander";
-import chalk7 from "chalk";
-import * as fs6 from "fs";
-import * as path6 from "path";
-import * as p10 from "@clack/prompts";
+import chalk8 from "chalk";
+import * as fs7 from "fs";
+import * as path7 from "path";
+import * as p11 from "@clack/prompts";
 var SKILL_TYPES = ["template", "integration", "ui", "ai", "workflow"];
 function generateReadme(manifest) {
   return `# ${manifest.name}
@@ -1366,23 +1451,23 @@ function toPascalCase(str) {
 var initCommand = new Command5("init").description("Initialize a new skill package").argument("<name>", "Skill name (slug format: lowercase-with-hyphens)").option("-t, --type <type>", "Skill type (template, integration, ui, ai, workflow)").option("-d, --dir <dir>", "Parent directory (default: current directory)").action(async (name, options) => {
   try {
     if (!/^[a-z][a-z0-9-]{1,62}[a-z0-9]$/.test(name)) {
-      console.error(chalk7.red("Error: Name must be lowercase alphanumeric with hyphens (2-64 chars, start with letter)"));
+      console.error(chalk8.red("Error: Name must be lowercase alphanumeric with hyphens (2-64 chars, start with letter)"));
       process.exit(1);
     }
-    const parentDir = options.dir ? path6.resolve(options.dir) : process.cwd();
-    const skillDir = path6.join(parentDir, name);
-    if (fs6.existsSync(skillDir)) {
-      console.error(chalk7.red(`Error: Directory "${name}" already exists`));
+    const parentDir = options.dir ? path7.resolve(options.dir) : process.cwd();
+    const skillDir = path7.join(parentDir, name);
+    if (fs7.existsSync(skillDir)) {
+      console.error(chalk8.red(`Error: Directory "${name}" already exists`));
       process.exit(1);
     }
-    console.log(chalk7.cyan(`
+    console.log(chalk8.cyan(`
 \u{1F4E6} Initializing skill: ${name}
 `));
     let type;
     if (options.type && SKILL_TYPES.includes(options.type)) {
       type = options.type;
     } else {
-      const result = await p10.select({
+      const result = await p11.select({
         message: "What type of skill are you creating?",
         options: [
           { value: "integration", label: "Integration", hint: "Connect to external services (Stripe, SendGrid, etc.)" },
@@ -1392,19 +1477,19 @@ var initCommand = new Command5("init").description("Initialize a new skill packa
           { value: "workflow", label: "Workflow", hint: "Automation recipes" }
         ]
       });
-      if (p10.isCancel(result)) {
-        p10.cancel("Operation cancelled");
+      if (p11.isCancel(result)) {
+        p11.cancel("Operation cancelled");
         process.exit(0);
       }
       type = result;
     }
-    const description = await p10.text({
+    const description = await p11.text({
       message: "Short description:",
       placeholder: `A ${type} skill for...`,
       validate: (v) => v.length < 10 ? "Description must be at least 10 characters" : void 0
     });
-    if (p10.isCancel(description)) {
-      p10.cancel("Operation cancelled");
+    if (p11.isCancel(description)) {
+      p11.cancel("Operation cancelled");
       process.exit(0);
     }
     const manifest = {
@@ -1429,22 +1514,22 @@ var initCommand = new Command5("init").description("Initialize a new skill packa
       },
       keywords: [type]
     };
-    fs6.mkdirSync(skillDir, { recursive: true });
-    fs6.mkdirSync(path6.join(skillDir, "src"), { recursive: true });
-    fs6.writeFileSync(
-      path6.join(skillDir, "githat-skill.json"),
+    fs7.mkdirSync(skillDir, { recursive: true });
+    fs7.mkdirSync(path7.join(skillDir, "src"), { recursive: true });
+    fs7.writeFileSync(
+      path7.join(skillDir, "githat-skill.json"),
       JSON.stringify(manifest, null, 2)
     );
-    fs6.writeFileSync(
-      path6.join(skillDir, "README.md"),
+    fs7.writeFileSync(
+      path7.join(skillDir, "README.md"),
       generateReadme(manifest)
     );
-    fs6.writeFileSync(
-      path6.join(skillDir, "src", "index.ts"),
+    fs7.writeFileSync(
+      path7.join(skillDir, "src", "index.ts"),
       generateIndexFile(manifest)
     );
-    fs6.writeFileSync(
-      path6.join(skillDir, ".gitignore"),
+    fs7.writeFileSync(
+      path7.join(skillDir, ".gitignore"),
       `node_modules/
 dist/
 .env
@@ -1452,21 +1537,21 @@ dist/
 *.log
 `
     );
-    console.log(chalk7.green(`
+    console.log(chalk8.green(`
 \u2705 Created skill at ${skillDir}
 `));
-    console.log(chalk7.dim("Files created:"));
-    console.log(chalk7.dim(`  githat-skill.json  - Skill manifest`));
-    console.log(chalk7.dim(`  README.md          - Documentation`));
-    console.log(chalk7.dim(`  src/index.ts       - Main entry point`));
-    console.log(chalk7.dim(`  .gitignore         - Git ignore rules`));
-    console.log(chalk7.dim("\nNext steps:"));
-    console.log(chalk7.dim(`  1. cd ${name}`));
-    console.log(chalk7.dim(`  2. Edit githat-skill.json with your details`));
-    console.log(chalk7.dim(`  3. Implement your skill in src/index.ts`));
-    console.log(chalk7.dim(`  4. Publish: githat skills publish .`));
+    console.log(chalk8.dim("Files created:"));
+    console.log(chalk8.dim(`  githat-skill.json  - Skill manifest`));
+    console.log(chalk8.dim(`  README.md          - Documentation`));
+    console.log(chalk8.dim(`  src/index.ts       - Main entry point`));
+    console.log(chalk8.dim(`  .gitignore         - Git ignore rules`));
+    console.log(chalk8.dim("\nNext steps:"));
+    console.log(chalk8.dim(`  1. cd ${name}`));
+    console.log(chalk8.dim(`  2. Edit githat-skill.json with your details`));
+    console.log(chalk8.dim(`  3. Implement your skill in src/index.ts`));
+    console.log(chalk8.dim(`  4. Publish: githat skills publish .`));
   } catch (err) {
-    console.error(chalk7.red(`Error: ${err.message}`));
+    console.error(chalk8.red(`Error: ${err.message}`));
     process.exit(1);
   }
 });
@@ -1474,7 +1559,7 @@ dist/
 // src/commands/skills/index.ts
 var skillsCommand = new Command6("skills").description("Manage GitHat skills marketplace").addCommand(searchCommand).addCommand(listCommand).addCommand(installCommand).addCommand(installedCommand).addCommand(initCommand);
 skillsCommand.action(() => {
-  console.log(chalk8.cyan("\n\u{1F4E6} GitHat Skills Marketplace\n"));
+  console.log(chalk9.cyan("\n\u{1F4E6} GitHat Skills Marketplace\n"));
   console.log("Commands:");
   console.log("  search <query>     Search skills by keyword");
   console.log("  list               List skills (filterable by type)");
@@ -1497,7 +1582,7 @@ program.command("create [project-name]", { isDefault: true }).description("Scaff
     displayBanner();
     const typescript = opts.js ? false : opts.ts ? true : void 0;
     if (opts.yes && !projectName) {
-      p11.cancel(chalk9.red("Project name is required when using --yes flag"));
+      p12.cancel(chalk10.red("Project name is required when using --yes flag"));
       process.exit(1);
     }
     const answers = await runPrompts({
@@ -1515,7 +1600,7 @@ program.command("create [project-name]", { isDefault: true }).description("Scaff
       skipPrompts: opts.yes
     });
   } catch (err) {
-    p11.cancel(chalk9.red(err.message || "Something went wrong."));
+    p12.cancel(chalk10.red(err.message || "Something went wrong."));
     process.exit(1);
   }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-githat-app",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "GitHat CLI — scaffold apps and manage the skills marketplace",
   "type": "module",
   "bin": {

package/templates/base/.env.local.example.hbs

@@ -0,0 +1,20 @@
+{{#ifEquals framework "nextjs"}}
+# GitHat — publishable key for this app.
+# Get yours at https://githat.io/dashboard/apps
+NEXT_PUBLIC_GITHAT_PUBLISHABLE_KEY=pk_live_your_key_here
+
+# GitHat API base URL (leave as-is unless using a self-hosted deployment)
+NEXT_PUBLIC_GITHAT_API_URL={{apiUrl}}
+{{else}}
+# GitHat — publishable key for this app.
+# Get yours at https://githat.io/dashboard/apps
+VITE_GITHAT_PUBLISHABLE_KEY=pk_live_your_key_here
+
+# GitHat API base URL (leave as-is unless using a self-hosted deployment)
+VITE_GITHAT_API_URL={{apiUrl}}
+{{/ifEquals}}
+{{#if useDatabase}}
+
+# Database
+DATABASE_URL="postgresql://user:password@localhost:5432/{{projectName}}"
+{{/if}}

package/templates/base/README.md.hbs

@@ -1,23 +1,21 @@
 # {{projectName}}
 
-Built with [GitHat](https://githat.io) — your backend is already set up. Auth, teams, orgs, API keys, MCP verification, and AI agent identity are handled by GitHat's hosted platform.
+Built with [GitHat](https://githat.io) — auth, teams, orgs, API keys, MCP verification, and AI agent identity are handled by GitHat's hosted platform.
 
 ## Getting Started
 
-1. Install dependencies:
+1. Copy the env file and fill in your GitHat key:
 
 ```bash
-{{#ifEquals packageManager "yarn"}}yarn{{else}}{{packageManager}} install{{/ifEquals}}
+cp .env.local.example .env.local
 ```
 
-2. Add your GitHat publishable key to `{{#ifEquals framework "nextjs"}}.env.local{{else}}.env{{/ifEquals}}`:
+2. Install dependencies:
 
-```env
-{{#ifEquals framework "nextjs"}}NEXT_PUBLIC_GITHAT_PUBLISHABLE_KEY{{else}}VITE_GITHAT_PUBLISHABLE_KEY{{/ifEquals}}=pk_live_your_key_here
+```bash
+{{#ifEquals packageManager "yarn"}}yarn{{else}}{{packageManager}} install{{/ifEquals}}
 ```
 
-Get your key at [githat.io/dashboard/apps](https://githat.io/dashboard/apps).
-
 3. Start the dev server:
 
 ```bash
@@ -26,36 +24,11 @@ Get your key at [githat.io/dashboard/apps](https://githat.io/dashboard/apps).
 
 4. Open [http://localhost:{{#ifEquals framework "nextjs"}}3000{{else}}5173{{/ifEquals}}](http://localhost:{{#ifEquals framework "nextjs"}}3000{{else}}5173{{/ifEquals}})
 
-## Your Backend
-
-All API calls go to `api.githat.io`. Your data is stored in GitHat's database. **No backend to deploy.**
-
-GitHat handles:
-
-- User auth (sign-up, sign-in, email verification, password reset)
-- Organizations (create, switch, branding)
-- Team management (invite members, assign roles)
-- API key management (publishable + secret keys)
-{{#if includeMcpModule}}- MCP server registration and domain verification
-{{/if}}{{#if includeAgentModule}}- AI agent registration and wallet verification
-{{/if}}- Email delivery (verification, invitations, password resets)
-
-The `githat/` folder in your project is a typed API client that talks to `api.githat.io`. You write frontend code, GitHat handles the rest.
-
-Manage everything at [githat.io/dashboard](https://githat.io/dashboard).
-
-## Pages
-
-- `/sign-in` — Sign in
-- `/sign-up` — Create account
-{{#if includeForgotPassword}}- `/forgot-password` — Password recovery
-{{/if}}{{#if includeDashboard}}- `/dashboard` — Protected dashboard
-{{/if}}{{#if includeOrgManagement}}- `/dashboard/members` — Invite members, manage roles
-{{/if}}
+Your `NEXT_PUBLIC_GITHAT_PUBLISHABLE_KEY` is required — get it at [githat.io/dashboard/apps](https://githat.io/dashboard/apps) or re-run `create-githat-app` after running `githat login` to have it auto-registered.
 
 ## GitHat SDK
 
-This project uses [`@githat/nextjs`](https://www.npmjs.com/package/@githat/nextjs) for connecting to the GitHat platform:
+This project uses [`@githat/nextjs`](https://www.npmjs.com/package/@githat/nextjs):
 
 ```{{#if typescript}}tsx{{else}}jsx{{/if}}
 import { useAuth, UserButton, OrgSwitcher } from '@githat/nextjs';
@@ -63,32 +36,38 @@ import { useAuth, UserButton, OrgSwitcher } from '@githat/nextjs';
 const { user, org, signIn, signUp, signOut } = useAuth();
 ```
 
-## Deploy
+## Deploy to EC2 via GitHub Actions
 
-{{#ifEquals framework "nextjs"}}### Vercel (recommended)
+The scaffolded `.github/workflows/deploy.yml` deploys the Next.js standalone bundle to an EC2 instance on every push to `main`.
 
-```bash
-npx vercel
-```
+**Required GitHub repo secrets:**
 
-Add `NEXT_PUBLIC_GITHAT_PUBLISHABLE_KEY` to your Vercel project environment variables.
-{{else}}### Vercel
+| Secret | Description |
+|--------|-------------|
+| `SSH_PRIVATE_KEY` | Private key whose public key is in the EC2 instance's `~/.ssh/authorized_keys` |
+| `EC2_HOST` | `ubuntu@<ec2-ip-or-hostname>` |
+| `PROD_ENV` | Full contents of your production `.env` file (set via `gh secret set PROD_ENV < .env.local`) |
+| `GITHAT_PUBLISHABLE_KEY` | Your GitHat publishable key (baked into the client bundle at build time) |
 
-```bash
-npx vercel
-```
+**One-time EC2 setup:**
 
-### Netlify
+1. Create a systemd service at `/etc/systemd/system/{{projectName}}.service` that runs `node /opt/{{projectName}}/server.js` with `PORT=3000`.
+2. Create `/opt/{{projectName}}/` owned by your deploy user.
+3. Enable the service: `sudo systemctl enable {{projectName}}`.
 
-```bash
-npx netlify deploy
-```
+After that, every `git push origin main` triggers a build + rsync + restart. The workflow smoke-tests `/api/health` before reporting success.
 
-Add `VITE_GITHAT_PUBLISHABLE_KEY` to your hosting provider's environment variables.
-{{/ifEquals}}
+## Pages
+
+- `/sign-in` — Sign in
+- `/sign-up` — Create account
+{{#if includeForgotPassword}}- `/forgot-password` — Password recovery
+{{/if}}{{#if includeDashboard}}- `/dashboard` — Protected dashboard
+{{/if}}{{#if includeOrgManagement}}- `/dashboard/members` — Invite members, manage roles
+{{/if}}
 
 ## Learn More
 
 - [GitHat Documentation](https://githat.io/docs)
 - [SDK Reference](https://www.npmjs.com/package/@githat/nextjs)
-- [API Reference (42+ endpoints)](https://githat.io/docs/api)
+- [API Reference](https://githat.io/docs/api)

package/templates/fullstack/apps-api-express/package.json.hbs

@@ -10,7 +10,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@githat/nextjs": "^0.2.2",
+    "@githat/nextjs": "^0.2.6",
     "cors": "^2.8.5",
     "express": "^5.0.0"
   },

package/templates/fullstack/apps-api-fastify/package.json.hbs

@@ -11,7 +11,7 @@
   },
   "dependencies": {
     "@fastify/cors": "^10.0.0",
-    "@githat/nextjs": "^0.2.2",
+    "@githat/nextjs": "^0.2.6",
     "fastify": "^5.2.0"
   },
   "devDependencies": {

package/templates/fullstack/apps-api-hono/package.json.hbs

@@ -10,7 +10,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@githat/nextjs": "^0.2.2",
+    "@githat/nextjs": "^0.2.6",
     "@hono/node-server": "^1.13.0",
     "hono": "^4.6.0"
   },

package/templates/fullstack/apps-web-nextjs/app/layout.tsx.hbs

@@ -20,6 +20,11 @@ export default function RootLayout({ children }{{#if typescript}}: { children: R
         }}>
           {children}
         </GitHatProvider>
+        <footer style=\{{ textAlign: 'center', padding: '1rem 0', fontSize: '0.75rem', color: '#52525b' }}>
+          <a href="https://githat.io" target="_blank" rel="noopener noreferrer" style=\{{ color: '#7c3aed', textDecoration: 'none' }}>
+            Powered by GitHat
+          </a>
+        </footer>
       </body>
     </html>
   );

package/templates/fullstack/apps-web-nextjs/package.json.hbs

@@ -10,7 +10,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@githat/nextjs": "^0.2.2",
+    "@githat/nextjs": "^0.2.6",
     "next": "^16.0.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0"

package/templates/nextjs/.github/workflows/deploy.yml.hbs

@@ -0,0 +1,107 @@
+name: Deploy to EC2
+
+# Auto-deploy every push to main. Also supports manual runs from the
+# Actions tab (workflow_dispatch) so you can re-ship without a dummy commit.
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+# Only one deploy at a time. Queue rather than race if a second push
+# lands mid-deploy.
+concurrency:
+  group: deploy-ec2
+  cancel-in-progress: false
+
+jobs:
+  build-and-deploy:
+    runs-on: ubuntu-latest
+    # Skip if commit message starts with "docs:" unless it includes [deploy].
+    if: $\{{ !startsWith(github.event.head_commit.message, 'docs:') || contains(github.event.head_commit.message, '[deploy]') }}
+    timeout-minutes: 12
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node 20
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          cache: "npm"
+
+      - name: Install deps
+        run: npm ci
+
+      - name: Type-check
+        run: npx tsc --noEmit
+
+      - name: Compute BUILD_ID
+        id: build_id
+        run: |
+          BUILD_ID=$(git rev-parse --short HEAD || echo "${GITHUB_SHA:0:7}")
+          echo "BUILD_ID=$BUILD_ID" >> "$GITHUB_OUTPUT"
+          echo "Resolved BUILD_ID=$BUILD_ID"
+
+      - name: Build (Next.js standalone)
+        run: npm run build
+        env:
+          # NEXT_PUBLIC_* vars are baked into the client bundle at build time.
+          # The real value comes from the GITHAT_PUBLISHABLE_KEY repo secret.
+          NEXT_PUBLIC_GITHAT_PUBLISHABLE_KEY: $\{{ secrets.GITHAT_PUBLISHABLE_KEY }}
+          BUILD_ID: $\{{ steps.build_id.outputs.BUILD_ID }}
+
+      - name: Load SSH key
+        run: |
+          mkdir -p ~/.ssh
+          echo "$\{{ secrets.SSH_PRIVATE_KEY }}" > ~/.ssh/deploy_key
+          chmod 600 ~/.ssh/deploy_key
+          ssh-keyscan -H "${EC2_HOST#*@}" >> ~/.ssh/known_hosts
+        env:
+          EC2_HOST: $\{{ secrets.EC2_HOST }}
+
+      - name: Sync production .env
+        env:
+          PROD_ENV: $\{{ secrets.PROD_ENV }}
+          EC2_HOST: $\{{ secrets.EC2_HOST }}
+        run: |
+          if [ -z "$PROD_ENV" ]; then
+            echo "PROD_ENV secret is empty — skipping env sync."
+            exit 0
+          fi
+          SSH_OPTS="-i ~/.ssh/deploy_key -o StrictHostKeyChecking=yes"
+          printf '%s' "$PROD_ENV" > /tmp/prod.env
+          rsync -az -e "ssh $SSH_OPTS" /tmp/prod.env "$EC2_HOST:/opt/{{projectName}}/.env"
+          shred -u /tmp/prod.env 2>/dev/null || rm -f /tmp/prod.env
+          ssh $SSH_OPTS "$EC2_HOST" \
+            "sudo chgrp {{projectName}} /opt/{{projectName}}/.env && sudo chmod 640 /opt/{{projectName}}/.env"
+
+      - name: Deploy to EC2
+        env:
+          EC2_HOST: $\{{ secrets.EC2_HOST }}
+        run: |
+          SSH_OPTS="-i ~/.ssh/deploy_key -o StrictHostKeyChecking=yes"
+
+          rsync -az --delete -e "ssh $SSH_OPTS" \
+              --exclude .env \
+              .next/standalone/ "$EC2_HOST:/opt/{{projectName}}/"
+
+          rsync -az -e "ssh $SSH_OPTS" \
+              .next/static/ "$EC2_HOST:/opt/{{projectName}}/.next/static/"
+
+          rsync -az -e "ssh $SSH_OPTS" \
+              public/ "$EC2_HOST:/opt/{{projectName}}/public/"
+
+          ssh $SSH_OPTS "$EC2_HOST" "
+            sudo systemctl restart {{projectName}}
+            sleep 5
+            sudo systemctl is-active --quiet {{projectName}} || { sudo journalctl -u {{projectName}} -n 30 --no-pager; exit 1; }
+            echo \"deployed build \$(cat /opt/{{projectName}}/.next/BUILD_ID)\"
+          "
+
+      - name: Smoke-test the deploy
+        env:
+          EC2_HOST: $\{{ secrets.EC2_HOST }}
+        run: |
+          SSH_OPTS="-i ~/.ssh/deploy_key -o StrictHostKeyChecking=yes"
+          ssh $SSH_OPTS "$EC2_HOST" \
+            "curl --fail --silent --show-error --max-time 10 http://127.0.0.1:3000/api/health > /dev/null && echo OK"

package/templates/nextjs/app/layout.tsx.hbs

@@ -27,6 +27,11 @@ export default function RootLayout({ children }{{#if typescript}}: { children: R
         }}>
           {children}
         </GitHatProvider>
+        <footer style=\{{ textAlign: 'center', padding: '1rem 0', fontSize: '0.75rem', color: '#52525b' }}>
+          <a href="https://githat.io" target="_blank" rel="noopener noreferrer" style=\{{ color: '#7c3aed', textDecoration: 'none' }}>
+            Powered by GitHat
+          </a>
+        </footer>
       </body>
     </html>
   );

package/templates/nextjs/next.config.ts.hbs

@@ -1,5 +1,7 @@
 import type { NextConfig } from 'next';
 
-const nextConfig: NextConfig = {};
+const nextConfig: NextConfig = {
+  output: 'standalone',
+};
 
 export default nextConfig;

package/templates/react-vite/src/App.tsx.hbs

@@ -27,20 +27,27 @@ function NotFound() {
 
 export default function App() {
   return (
-    <Routes>
-      <Route path="/" element={<Home />} />
-      <Route path="/sign-in" element={<SignIn />} />
-      <Route path="/sign-up" element={<SignUp />} />
+    <>
+      <Routes>
+        <Route path="/" element={<Home />} />
+        <Route path="/sign-in" element={<SignIn />} />
+        <Route path="/sign-up" element={<SignUp />} />
 {{#if includeForgotPassword}}
-      <Route path="/forgot-password" element={<ForgotPassword />} />
+        <Route path="/forgot-password" element={<ForgotPassword />} />
 {{/if}}
 {{#if includeEmailVerification}}
-      <Route path="/verify-email" element={<VerifyEmail />} />
+        <Route path="/verify-email" element={<VerifyEmail />} />
 {{/if}}
 {{#if includeDashboard}}
-      <Route path="/dashboard/*" element={<ProtectedRoute><Dashboard /></ProtectedRoute>} />
+        <Route path="/dashboard/*" element={<ProtectedRoute><Dashboard /></ProtectedRoute>} />
 {{/if}}
-      <Route path="*" element={<NotFound />} />
-    </Routes>
+        <Route path="*" element={<NotFound />} />
+      </Routes>
+      <footer style=\{{ textAlign: 'center', padding: '1rem 0', fontSize: '0.75rem', color: '#52525b' }}>
+        <a href="https://githat.io" target="_blank" rel="noopener noreferrer" style=\{{ color: '#7c3aed', textDecoration: 'none' }}>
+          Powered by GitHat
+        </a>
+      </footer>
+    </>
   );
 }