@sansavision/create-pulse 0.4.4 → 0.4.6

package/templates/aurora-auth-node-demo/drizzle.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+    dialect: "sqlite",
+    schema: "./src/lib/schema.ts",
+    dbCredentials: {
+        url: "./sqlite.db",
+    },
+});

package/templates/aurora-auth-node-demo/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "pulse-aurora-auth-node-demo",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "NODE_ENV=development bun server.mjs",
+    "build": "aurora build --target node",
+    "start": "NODE_ENV=production bun server.mjs",
+    "doctor": "aurora doctor",
+    "db:push": "bunx drizzle-kit push",
+    "db:generate": "bunx drizzle-kit generate",
+    "db:migrate": "bunx drizzle-kit migrate",
+    "db:studio": "bunx drizzle-kit studio"
+  },
+  "dependencies": {
+    "@sansavision/aurora": "0.1.0-alpha.20260307.5",
+    "@sansavision/pulse-node": "file:../../../pulse-node",
+    "@sansavision/pulse-sdk": "^0.4.2",
+    "better-auth": "^1.2.0",
+    "better-sqlite3": "^12.0.0",
+    "drizzle-orm": "^0.41.0",
+    "lucide-react": "^0.412.0",
+    "react": "19.2.3",
+    "react-dom": "19.2.3",
+    "react-player": "^2.16.0"
+  },
+  "devDependencies": {
+    "@tailwindcss/cli": "^4.2.1",
+    "@tailwindcss/postcss": "^4",
+    "@types/better-sqlite3": "^7.6.0",
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "drizzle-kit": "^0.31.0",
+    "tailwindcss": "^4.2.1",
+    "typescript": "^5"
+  }
+}

package/templates/aurora-auth-node-demo/postcss.config.mjs

@@ -0,0 +1,7 @@
+const config = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};
+
+export default config;

package/templates/aurora-auth-node-demo/server.mjs

@@ -0,0 +1,46 @@
+import { spawn } from "node:child_process";
+import { PulseRelay } from "@sansavision/pulse-node";
+import { fileURLToPath } from "node:url";
+
+const dev = process.env.NODE_ENV !== "production";
+const hostname = process.env.HOST || "localhost";
+const port = parseInt(process.env.PORT || "3000", 10);
+const pulsePort = parseInt(process.env.PULSE_PORT || "4001", 10);
+
+// ── Start the embedded Pulse relay ──────────────────────────────────────────
+const relay = new PulseRelay({
+  bind: `0.0.0.0:${pulsePort}`,
+  enableWebsocket: true,
+});
+
+const info = await relay.start();
+console.log(`⚡ Pulse Relay running on port ${info.wsPort || info.quicPort}`);
+console.log(`   Region: ${info.region}  |  Capacity: ${info.capacity}`);
+
+// ── Start Web Server ────────────────────────────────────────────────────────
+const args = dev ? ["run", "dev"] : ["run", "start"];
+args.push("--port", port.toString());
+
+const cp = spawn("bunx", ["aurora", ...args.slice(1)], {
+  stdio: "inherit",
+  env: process.env,
+});
+
+cp.on("close", (code) => {
+  console.log(`Aurora exited with code ${code}`);
+  shutdown();
+});
+
+// ── Graceful shutdown ───────────────────────────────────────────────────────
+const shutdown = async () => {
+  console.log("\n🛑 Shutting down...");
+  await relay.stop();
+  if (cp.exitCode === null) {
+    cp.kill();
+  }
+  process.exit(0);
+};
+
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);
+

package/templates/aurora-auth-node-demo/src/actions/createMessage.action.server.ts

@@ -0,0 +1,31 @@
+// aurora:justify-auth-none: template demo action; replace with real authentication (e.g. .auth("required")) before shipping.
+import { err, ok, s, server } from "@sansavision/aurora";
+
+import { requireUser } from "../lib/auth.server";
+import { appendMessage } from "../queries/listMessages.server";
+
+const createMessageInput = s.object({
+  text: s.string().trim().min(1).max(500),
+});
+
+export const createMessage = server
+  .action("messages.create")
+  .input(createMessageInput)
+  .handler(async ({ input }: { input: { text: string } }) => {
+    if (input.text.length > 280) {
+      return err("MESSAGE_TOO_LONG", {
+        max: 280,
+      });
+    }
+
+    const user = await requireUser();
+    const record = appendMessage(input.text);
+
+    return ok({
+      ...record,
+      authorId: user.id,
+    });
+  })
+  .invalidates(["messages"])
+  .auth("none")
+  .errors(["MESSAGE_TOO_LONG"] as const);

package/templates/aurora-auth-node-demo/src/aurora.auth.ts

@@ -0,0 +1,65 @@
+import { defineAuthPipeline } from "@sansavision/aurora/server";
+import { auth } from "@/lib/auth";
+
+function normalizeAuroraRoles(role: string | undefined): string[] {
+    if (role === "game_master") {
+        return ["user", "admin"];
+    }
+    return ["user"];
+}
+
+export default defineAuthPipeline({
+    async resolve(request: Request) {
+        const cookieHeader = request.headers.get("cookie") ?? "";
+        if (!cookieHeader) {
+            return null;
+        }
+
+        const headers = new Headers();
+        headers.set("cookie", cookieHeader);
+
+        const session = await auth.api.getSession({ headers });
+
+        if (!session?.user?.id) {
+            return null;
+        }
+
+        // Better Auth's getSession returns the full user row — our custom
+        // `role` column is present at runtime but not in the default TS types.
+        const userRecord = session.user as typeof session.user & { role?: string };
+        const roles = normalizeAuroraRoles(userRecord.role);
+
+        return {
+            authenticated: true,
+            subjectId: session.user.id,
+            roles,
+            permissions: [],
+            provider: "better-auth",
+            claims: {
+                email: session.user.email,
+                name: session.user.name,
+                role: userRecord.role ?? "player",
+            },
+        };
+    },
+    deny: {
+        redirect: "/auth/login",
+    },
+    routing: [
+        {
+            path: "/auth/login",
+            condition: "authenticated",
+            redirect: "/",
+        },
+        {
+            path: "/lobbies",
+            condition: "unauthenticated",
+            redirect: "/auth/login",
+        },
+        {
+            path: "/matches",
+            condition: "unauthenticated",
+            redirect: "/auth/login",
+        },
+    ],
+});

package/templates/aurora-auth-node-demo/src/lib/auth-client.ts

@@ -0,0 +1,30 @@
+import { createAuthClient } from "better-auth/react";
+
+// Aurora only dispatches handler.ts files for non-GET HTTP methods.
+// better-auth uses GET for /get-session. We wrap fetch to convert
+// those GETs into POSTs so they hit the handler instead of the page renderer.
+const auroraFetch: typeof fetch = (input, init) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    if (url.includes("/api/auth/") && (!init?.method || init.method === "GET")) {
+        return fetch(input, { ...init, method: "POST" });
+    }
+    return fetch(input, init);
+};
+
+export const authClient = createAuthClient({
+    baseURL: typeof window !== "undefined" ? window.location.origin : "http://localhost:3000",
+    fetchOptions: {
+        customFetchImpl: auroraFetch,
+        onSuccess: (ctx) => {
+            const authToken = ctx.response.headers.get("set-auth-token");
+            if (authToken && typeof window !== "undefined") {
+                localStorage.setItem("pulse_bearer_token", authToken);
+            }
+        },
+    },
+});
+
+export const signIn = authClient.signIn;
+export const signUp = authClient.signUp;
+export const signOut = authClient.signOut;
+export const useSession = authClient.useSession;

package/templates/aurora-auth-node-demo/src/lib/auth.server.ts

@@ -0,0 +1,11 @@
+export interface AuthUser {
+  id: string;
+  role: "admin" | "user";
+}
+
+export async function requireUser(): Promise<AuthUser> {
+  return {
+    id: "demo-user",
+    role: "admin",
+  };
+}

package/templates/aurora-auth-node-demo/src/lib/auth.ts

@@ -0,0 +1,30 @@
+import { betterAuth } from "better-auth";
+import { drizzleAdapter } from "better-auth/adapters/drizzle";
+import { bearer } from "better-auth/plugins";
+import { db } from "./db";
+import * as schema from "./schema";
+
+const baseURL =
+    process.env.BETTER_AUTH_URL ||
+    `http://localhost:${process.env.PORT || "3000"}`;
+
+export const auth = betterAuth({
+    baseURL,
+    database: drizzleAdapter(db, { provider: "sqlite", schema }),
+    emailAndPassword: {
+        enabled: true,
+    },
+    session: {
+        // Aurora only dispatches handler.ts for non-GET methods, so the
+        // client converts GET /get-session → POST. better-auth requires
+        // deferSessionRefresh to accept POST on the get-session endpoint.
+        deferSessionRefresh: true,
+    },
+    plugins: [bearer()],
+    // In production, set BETTER_AUTH_URL to your domain.
+    // In dev, we trust any localhost origin regardless of port.
+    trustedOrigins: (origin) => {
+        if (origin.startsWith("http://localhost:")) return true;
+        return origin === baseURL;
+    },
+});

package/templates/aurora-auth-node-demo/src/lib/db.ts

@@ -0,0 +1,6 @@
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import * as schema from "./schema";
+
+const sqlite = new Database("./sqlite.db");
+export const db = drizzle(sqlite, { schema });

package/templates/aurora-auth-node-demo/src/lib/pulse.ts

@@ -0,0 +1,45 @@
+"use client";
+
+import { Pulse } from "@sansavision/pulse-sdk";
+
+let pulseInstance: Pulse | null = null;
+
+export function getPulse(): Pulse {
+    if (!pulseInstance) {
+        pulseInstance = new Pulse({ apiKey: "demo" });
+    }
+    return pulseInstance;
+}
+
+/**
+ * Get the bearer token stored by Better Auth for Pulse auth.
+ */
+export function getPulseToken(): string | null {
+    if (typeof window === "undefined") return null;
+    return localStorage.getItem("pulse_bearer_token");
+}
+
+/**
+ * Connect to the Pulse relay with authentication.
+ * Uses the Better Auth bearer token for the PLP CONNECT handshake.
+ */
+export async function connectWithAuth() {
+    const pulse = getPulse();
+    const token = getPulseToken();
+    const url = process.env.NEXT_PUBLIC_PULSE_URL || "ws://localhost:4001";
+
+    const conn = await pulse.connect(url, {
+        encoding: "json",
+        autoReconnect: true,
+        ...(token
+            ? {
+                auth: {
+                    token,
+                    provider: "better-auth",
+                },
+            }
+            : {}),
+    });
+
+    return conn;
+}

package/templates/aurora-auth-node-demo/src/lib/schema.ts

@@ -0,0 +1,107 @@
+import { relations, sql } from "drizzle-orm";
+import { sqliteTable, text, integer, index } from "drizzle-orm/sqlite-core";
+
+export const user = sqliteTable("user", {
+    id: text("id").primaryKey(),
+    name: text("name").notNull(),
+    email: text("email").notNull().unique(),
+    emailVerified: integer("email_verified", { mode: "boolean" })
+        .default(false)
+        .notNull(),
+    image: text("image"),
+    createdAt: integer("created_at", { mode: "timestamp_ms" })
+        .default(sql`(cast(unixepoch('subsecond') * 1000 as integer))`)
+        .notNull(),
+    updatedAt: integer("updated_at", { mode: "timestamp_ms" })
+        .default(sql`(cast(unixepoch('subsecond') * 1000 as integer))`)
+        .$onUpdate(() => /* @__PURE__ */ new Date())
+        .notNull(),
+});
+
+export const session = sqliteTable(
+    "session",
+    {
+        id: text("id").primaryKey(),
+        expiresAt: integer("expires_at", { mode: "timestamp_ms" }).notNull(),
+        token: text("token").notNull().unique(),
+        createdAt: integer("created_at", { mode: "timestamp_ms" })
+            .default(sql`(cast(unixepoch('subsecond') * 1000 as integer))`)
+            .notNull(),
+        updatedAt: integer("updated_at", { mode: "timestamp_ms" })
+            .$onUpdate(() => /* @__PURE__ */ new Date())
+            .notNull(),
+        ipAddress: text("ip_address"),
+        userAgent: text("user_agent"),
+        userId: text("user_id")
+            .notNull()
+            .references(() => user.id, { onDelete: "cascade" }),
+    },
+    (table) => [index("session_userId_idx").on(table.userId)],
+);
+
+export const account = sqliteTable(
+    "account",
+    {
+        id: text("id").primaryKey(),
+        accountId: text("account_id").notNull(),
+        providerId: text("provider_id").notNull(),
+        userId: text("user_id")
+            .notNull()
+            .references(() => user.id, { onDelete: "cascade" }),
+        accessToken: text("access_token"),
+        refreshToken: text("refresh_token"),
+        idToken: text("id_token"),
+        accessTokenExpiresAt: integer("access_token_expires_at", {
+            mode: "timestamp_ms",
+        }),
+        refreshTokenExpiresAt: integer("refresh_token_expires_at", {
+            mode: "timestamp_ms",
+        }),
+        scope: text("scope"),
+        password: text("password"),
+        createdAt: integer("created_at", { mode: "timestamp_ms" })
+            .default(sql`(cast(unixepoch('subsecond') * 1000 as integer))`)
+            .notNull(),
+        updatedAt: integer("updated_at", { mode: "timestamp_ms" })
+            .$onUpdate(() => /* @__PURE__ */ new Date())
+            .notNull(),
+    },
+    (table) => [index("account_userId_idx").on(table.userId)],
+);
+
+export const verification = sqliteTable(
+    "verification",
+    {
+        id: text("id").primaryKey(),
+        identifier: text("identifier").notNull(),
+        value: text("value").notNull(),
+        expiresAt: integer("expires_at", { mode: "timestamp_ms" }).notNull(),
+        createdAt: integer("created_at", { mode: "timestamp_ms" })
+            .default(sql`(cast(unixepoch('subsecond') * 1000 as integer))`)
+            .notNull(),
+        updatedAt: integer("updated_at", { mode: "timestamp_ms" })
+            .default(sql`(cast(unixepoch('subsecond') * 1000 as integer))`)
+            .$onUpdate(() => /* @__PURE__ */ new Date())
+            .notNull(),
+    },
+    (table) => [index("verification_identifier_idx").on(table.identifier)],
+);
+
+export const userRelations = relations(user, ({ many }) => ({
+    sessions: many(session),
+    accounts: many(account),
+}));
+
+export const sessionRelations = relations(session, ({ one }) => ({
+    user: one(user, {
+        fields: [session.userId],
+        references: [user.id],
+    }),
+}));
+
+export const accountRelations = relations(account, ({ one }) => ({
+    user: one(user, {
+        fields: [account.userId],
+        references: [user.id],
+    }),
+}));

package/templates/aurora-auth-node-demo/src/queries/listMessages.server.ts

@@ -0,0 +1,25 @@
+import { server } from "@sansavision/aurora";
+
+export interface MessageListItem {
+  id: string;
+  text: string;
+  createdAt: number;
+}
+
+const messages: MessageListItem[] = [];
+
+export function appendMessage(text: string): MessageListItem {
+  const record: MessageListItem = {
+    id: `msg-${Date.now()}`,
+    text,
+    createdAt: Date.now(),
+  };
+
+  messages.unshift(record);
+  return record;
+}
+
+export const listMessages = server
+  .query("messages.list", async () => messages)
+  .key(() => ["messages", "list"])
+  .tags(() => ["messages"]);

package/templates/aurora-auth-node-demo/src/routes/api/auth/[...slug]/handler.ts

@@ -0,0 +1,14 @@
+import { auth } from "@/lib/auth";
+
+// Aurora handler resolution requires a default export.
+// Aurora may pass either a raw Request or a context object { request, params }.
+// We handle both cases.
+export default async function handler(input: Request | { request: Request; params?: Record<string, string> }) {
+    const request = input instanceof Request ? input : input.request;
+    try {
+        return await auth.handler(request);
+    } catch (error) {
+        console.error("[auth handler] Error:", error);
+        return Response.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

package/templates/aurora-auth-node-demo/src/routes/api/pulse/verify/handler.ts

@@ -0,0 +1,55 @@
+import { auth } from "@/lib/auth";
+
+// Aurora handler resolution requires a default export.
+// Aurora may pass either a raw Request or a context object { request, params }.
+export default async function handler(input: Request | { request: Request; params?: Record<string, string> }) {
+    const request = input instanceof Request ? input : input.request;
+
+    if (request.method !== "POST") {
+        return Response.json(
+            { error: "Method not allowed" },
+            { status: 405 }
+        );
+    }
+
+    try {
+        const body = await request.json();
+        const { token } = body;
+
+        if (!token) {
+            return Response.json(
+                { allow: false, reason: "No token provided" },
+                { status: 200 }
+            );
+        }
+
+        // Verify the bearer token against Better Auth's session store
+        const session = await auth.api.getSession({
+            headers: new Headers({
+                Authorization: `Bearer ${token}`,
+            }),
+        });
+
+        if (!session?.user) {
+            return Response.json(
+                { allow: false, reason: "Invalid or expired session token" },
+                { status: 200 }
+            );
+        }
+
+        return Response.json({
+            allow: true,
+            user_id: session.user.id,
+            claims: {
+                email: session.user.email || "",
+                name: session.user.name || "",
+            },
+        });
+    } catch (error) {
+        console.error("[Pulse Verify] Error:", error);
+        return Response.json(
+            { allow: false, reason: "Internal verification error" },
+            { status: 200 }
+        );
+    }
+}

package/templates/aurora-auth-node-demo/src/routes/auth/sign-in/page.client.tsx

@@ -0,0 +1,132 @@
+
+
+import { useState } from "react";
+import { createClientNavigation } from "@sansavision/aurora/router";
+
+import { signIn } from "@/lib/auth-client";
+import { Zap, Mail, Lock, ArrowRight, Loader2 } from "lucide-react";
+
+export default function SignInPage() {
+    const router = createClientNavigation();
+    const [email, setEmail] = useState("");
+    const [password, setPassword] = useState("");
+    const [error, setError] = useState("");
+    const [loading, setLoading] = useState(false);
+
+    async function handleSubmit(e: React.FormEvent) {
+        e.preventDefault();
+        setError("");
+        setLoading(true);
+
+        try {
+            const result = await signIn.email({
+                email,
+                password,
+            });
+
+            if (result.error) {
+                setError(result.error.message || "Sign in failed");
+            } else {
+                router.navigate("/dashboard");
+            }
+        } catch {
+            setError("An unexpected error occurred");
+        } finally {
+            setLoading(false);
+        }
+    }
+
+    return (
+        <div className="min-h-screen flex items-center justify-center px-4 relative overflow-hidden">
+            {/* Background effects */}
+            <div className="absolute top-1/4 left-1/3 w-80 h-80 bg-purple-500/15 rounded-full blur-[100px]" />
+            <div className="absolute bottom-1/4 right-1/3 w-80 h-80 bg-cyan-500/15 rounded-full blur-[100px]" />
+
+            <div className="w-full max-w-md relative z-10">
+                {/* Logo */}
+                <div className="text-center mb-8">
+                    <a href="/" className="inline-flex items-center gap-2 mb-6">
+                        <div className="w-10 h-10 rounded-xl bg-gradient-to-br from-purple-500 to-cyan-500 flex items-center justify-center">
+                            <Zap className="w-6 h-6 text-white" />
+                        </div>
+                        <span className="text-2xl font-bold">Pulse</span>
+                    </a>
+                    <h1 className="text-2xl font-bold mb-2">Welcome back</h1>
+                    <p className="text-slate-400">Sign in to access the demo dashboard</p>
+                </div>
+
+                {/* Form */}
+                <form
+                    method="post"
+                    onSubmit={handleSubmit}
+                    className="glass rounded-2xl p-8 space-y-5"
+                >
+                    {error && (
+                        <div className="p-3 rounded-lg bg-red-500/10 border border-red-500/20 text-red-400 text-sm">
+                            {error}
+                        </div>
+                    )}
+
+                    <div>
+                        <label className="block text-sm font-medium text-slate-300 mb-1.5">
+                            Email
+                        </label>
+                        <div className="relative">
+                            <Mail className="absolute left-3 top-1/2 -translate-y-1/2 w-4 h-4 text-slate-500" />
+                            <input
+                                type="email"
+                                value={email}
+                                onChange={(e) => setEmail(e.target.value)}
+                                placeholder="you@example.com"
+                                required
+                                className="w-full pl-10 pr-4 py-2.5 rounded-lg bg-slate-800/50 border border-slate-700 focus:border-purple-500 focus:ring-1 focus:ring-purple-500 outline-none text-sm transition-colors placeholder:text-slate-600"
+                            />
+                        </div>
+                    </div>
+
+                    <div>
+                        <label className="block text-sm font-medium text-slate-300 mb-1.5">
+                            Password
+                        </label>
+                        <div className="relative">
+                            <Lock className="absolute left-3 top-1/2 -translate-y-1/2 w-4 h-4 text-slate-500" />
+                            <input
+                                type="password"
+                                value={password}
+                                onChange={(e) => setPassword(e.target.value)}
+                                placeholder="••••••••"
+                                required
+                                className="w-full pl-10 pr-4 py-2.5 rounded-lg bg-slate-800/50 border border-slate-700 focus:border-purple-500 focus:ring-1 focus:ring-purple-500 outline-none text-sm transition-colors placeholder:text-slate-600"
+                            />
+                        </div>
+                    </div>
+
+                    <button
+                        type="submit"
+                        disabled={loading}
+                        className="w-full py-2.5 bg-gradient-to-r from-purple-600 to-purple-500 hover:from-purple-500 hover:to-purple-400 rounded-lg font-semibold transition-all hover:shadow-lg hover:shadow-purple-500/25 disabled:opacity-50 disabled:cursor-not-allowed flex items-center justify-center gap-2"
+                    >
+                        {loading ? (
+                            <Loader2 className="w-4 h-4 animate-spin" />
+                        ) : (
+                            <>
+                                Sign In
+                                <ArrowRight className="w-4 h-4" />
+                            </>
+                        )}
+                    </button>
+
+                    <p className="text-center text-sm text-slate-400">
+                        Don&apos;t have an account?{" "}
+                        <a
+                            href="/auth/sign-up"
+                            className="text-purple-400 hover:text-purple-300 font-medium"
+                        >
+                            Create one
+                        </a>
+                    </p>
+                </form>
+            </div>
+        </div>
+    );
+}

package/templates/aurora-auth-node-demo/src/routes/auth/sign-in/page.tsx

@@ -0,0 +1,5 @@
+import SignInPage from "./page.client";
+
+export default function Page() {
+    return <SignInPage />;
+}