treewide: add DISABLE_AUTH feature flag and seed script

- Add DISABLE_AUTH env var to bypass authentication with mock user
- Add PUBLIC_DISABLE_AUTH for frontend
- Fix WebSocket message handling with proper Elysia body schema
- Initialize WebSocket connection in root layout
- Add scripts/seed.ts to seed mock user, org, and channel

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: aster-void

.env.sample

@@ -9,3 +9,6 @@ BETTER_AUTH_SECRET=your-secret-key-at-least-32-characters
 # Google OAuth
 GOOGLE_CLIENT_ID=your-google-client-id
 GOOGLE_CLIENT_SECRET=your-google-client-secret
+# Feature Flags
+DISABLE_AUTH=false
+PUBLIC_DISABLE_AUTH=false

apps/desktop/src/lib/env.ts

@@ -2,10 +2,12 @@ import * as v from "valibot";
 
 const envSchema = v.object({
   PUBLIC_API_BASE_URL: v.pipe(v.string(), v.url()),
+  PUBLIC_DISABLE_AUTH: v.optional(v.string(), "false"),
 });
 
 const result = v.safeParse(envSchema, {
   PUBLIC_API_BASE_URL: import.meta.env.PUBLIC_API_BASE_URL,
+  PUBLIC_DISABLE_AUTH: import.meta.env.PUBLIC_DISABLE_AUTH,
 });
 
 if (!result.success) {
@@ -16,3 +18,5 @@ if (!result.success) {
 }
 
 export const env = result.output;
+
+export const isAuthDisabled = () => env.PUBLIC_DISABLE_AUTH === "true";

apps/desktop/src/routes/+layout.svelte

@@ -1,11 +1,22 @@
 <script lang="ts">
   import "@/app.css";
   import { setupApi } from "@/lib/api.svelte.ts";
+  import { env } from "@/lib/env.ts";
+  import { setupWebSocket } from "@/lib/websocket/index.ts";
 
   const { children } = $props();
 
   // Initialize API client (uses PUBLIC_API_BASE_URL env var)
   setupApi();
+
+  // Initialize WebSocket client
+  const wsUrl = `${env.PUBLIC_API_BASE_URL.replace(/^http/, "ws")}/ws`;
+  const ws = setupWebSocket(wsUrl);
+
+  $effect(() => {
+    ws.connect();
+    return () => ws.disconnect();
+  });
 </script>
 
 {@render children()}

apps/server/package.json

@@ -8,7 +8,7 @@
   "scripts": {
     "dev": "bun run --watch src/index.ts",
     "check": "tsc --noEmit",
-    "db:migrate": "drizzle-kit migrate"
+    "db": "drizzle-kit"
   },
   "dependencies": {
     "@bogeychan/elysia-logger": "^0.1.10",

apps/server/src/env.ts

@@ -7,6 +7,13 @@ const envSchema = v.object({
   PORT: v.optional(v.pipe(v.string(), v.transform(Number)), "3000"),
   GOOGLE_CLIENT_ID: v.pipe(v.string(), v.minLength(1)),
   GOOGLE_CLIENT_SECRET: v.pipe(v.string(), v.minLength(1)),
+  DISABLE_AUTH: v.optional(
+    v.pipe(
+      v.string(),
+      v.transform((s) => s === "true"),
+    ),
+    "false",
+  ),
 });
 
 const result = v.safeParse(envSchema, process.env);

apps/server/src/middleware/auth.ts

@@ -1,15 +1,26 @@
 import { Elysia } from "elysia";
 import { auth } from "../auth.ts";
+import { env } from "../env.ts";
 
 export interface AuthUser {
   id: string;
   email: string;
   name?: string;
 }
 
+const MOCK_USER: AuthUser = {
+  id: "dev-user-id",
+  email: "[email protected]",
+  name: "Dev User",
+};
+
 export const authMiddleware = new Elysia({ name: "auth" }).derive(
   { as: "global" },
   async ({ request }) => {
+    if (env.DISABLE_AUTH) {
+      return { user: MOCK_USER as AuthUser | null };
+    }
+
     const session = await auth.api.getSession({ headers: request.headers });
 
     if (!session?.user) {

apps/server/src/ws/index.ts

@@ -1,13 +1,21 @@
-import { Elysia } from "elysia";
+import { Elysia, t } from "elysia";
 import { authMiddleware } from "../middleware/auth.ts";
 import { wsManager } from "./manager.ts";
-import type { WsClientMessage, WsConnection } from "./types.ts";
+import type { WsConnection } from "./types.ts";
 
 /**
  * WebSocket routes for real-time communication.
  * Handles channel subscriptions and broadcasts events to connected clients.
  */
+const wsClientMessage = t.Union([
+  t.Object({ type: t.Literal("subscribe"), channelId: t.String() }),
+  t.Object({ type: t.Literal("unsubscribe"), channelId: t.String() }),
+  t.Object({ type: t.Literal("ping") }),
+]);
+
 export const wsRoutes = new Elysia().use(authMiddleware).ws("/ws", {
+  body: wsClientMessage,
+
   open(ws) {
     const user = ws.data.user;
     if (!user) {
@@ -29,32 +37,22 @@ export const wsRoutes = new Elysia().use(authMiddleware).ws("/ws", {
     const user = ws.data.user;
     if (!user) return;
 
-    try {
-      const data = JSON.parse(String(msg)) as WsClientMessage;
-
-      if (data.type === "subscribe") {
-        const connections = Array.from(wsManager.connections.values());
-        const conn = connections.find((c) => c.user.id === user.id);
-        if (conn) {
-          wsManager.subscribe(conn.id, data.channelId);
-          ws.send(
-            JSON.stringify({ type: "subscribed", channelId: data.channelId }),
-          );
-        }
-      } else if (data.type === "unsubscribe") {
-        const connections = Array.from(wsManager.connections.values());
-        const conn = connections.find((c) => c.user.id === user.id);
-        if (conn) {
-          wsManager.unsubscribe(conn.id, data.channelId);
-          ws.send(
-            JSON.stringify({ type: "unsubscribed", channelId: data.channelId }),
-          );
-        }
-      } else if (data.type === "ping") {
-        ws.send(JSON.stringify({ type: "pong" }));
+    if (msg.type === "subscribe") {
+      const connections = Array.from(wsManager.connections.values());
+      const conn = connections.find((c) => c.user.id === user.id);
+      if (conn) {
+        wsManager.subscribe(conn.id, msg.channelId);
+        ws.send({ type: "subscribed", channelId: msg.channelId });
+      }
+    } else if (msg.type === "unsubscribe") {
+      const connections = Array.from(wsManager.connections.values());
+      const conn = connections.find((c) => c.user.id === user.id);
+      if (conn) {
+        wsManager.unsubscribe(conn.id, msg.channelId);
+        ws.send({ type: "unsubscribed", channelId: msg.channelId });
       }
-    } catch (error) {
-      console.error("WebSocket message error:", error);
+    } else if (msg.type === "ping") {
+      ws.send({ type: "pong" });
     }
   },
 

package.json

@@ -15,7 +15,8 @@
     "fix:format": "prettier --write . --log-level warn",
     "check:lint": "bun biome check",
     "fix:lint": "bun biome check --fix --unsafe",
-    "db": "cd apps/server && bun --env-file=../../.env run drizzle-kit"
+    "db": "cd apps/server && bun --env-file=../../.env run drizzle-kit",
+    "db:seed": "bun --env-file=.env run scripts/seed.ts"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.8",

scripts/seed.ts

@@ -0,0 +1,75 @@
+import { users } from "../apps/server/src/db/auth.ts";
+import { channels } from "../apps/server/src/db/channels.ts";
+import { db } from "../apps/server/src/db/index.ts";
+import {
+  organizationMembers,
+  organizations,
+} from "../apps/server/src/db/organizations.ts";
+
+const MOCK_USER = {
+  id: "dev-user-id",
+  name: "Dev User",
+  email: "[email protected]",
+};
+
+const MOCK_ORG = {
+  name: "Dev Organization",
+  description: "Default organization for development",
+};
+
+async function seed() {
+  console.log("🌱 Seeding database...");
+
+  // Create mock user
+  const [user] = await db
+    .insert(users)
+    .values(MOCK_USER)
+    .onConflictDoNothing()
+    .returning();
+
+  if (user) {
+    console.log(`✅ Created user: ${user.name}`);
+  } else {
+    console.log(`⏭️  User already exists: ${MOCK_USER.name}`);
+  }
+
+  // Create mock organization
+  const [org] = await db
+    .insert(organizations)
+    .values({ ...MOCK_ORG, ownerId: MOCK_USER.id })
+    .onConflictDoNothing()
+    .returning();
+
+  if (org) {
+    console.log(`✅ Created organization: ${org.name}`);
+
+    // Add user as admin member
+    await db.insert(organizationMembers).values({
+      organizationId: org.id,
+      userId: MOCK_USER.id,
+      permission: "admin",
+    });
+    console.log(`✅ Added ${MOCK_USER.name} as admin`);
+
+    // Create general channel
+    const [channel] = await db
+      .insert(channels)
+      .values({
+        name: "general",
+        description: "General discussion",
+        organizationId: org.id,
+      })
+      .returning();
+    console.log(`✅ Created channel: #${channel.name}`);
+  } else {
+    console.log("⏭️  Organization already exists");
+  }
+
+  console.log("🌱 Seeding complete!");
+  process.exit(0);
+}
+
+seed().catch((err) => {
+  console.error("❌ Seeding failed:", err);
+  process.exit(1);
+});