create-kuckit-app 0.4.0 → 0.4.1

package/templates/base/apps/web/AGENTS.md

@@ -10,118 +10,96 @@ React frontend using TanStack Router, TanStack Query, and Kuckit client modules.
 
 | File                               | Purpose                           |
 | ---------------------------------- | --------------------------------- |
-| `main.tsx`                         | App entry point                   |
+| `main.tsx`                         | App entry point (17 lines)        |
 | `modules.client.ts`                | Client module registration        |
-| `providers/KuckitProvider.tsx`     | Kuckit context setup              |
-| `providers/ServicesProvider.tsx`   | Services context (RPC, auth)      |
 | `routes/`                          | TanStack Router file-based routes |
 | `routes/$.tsx`                     | Catch-all for module routes       |
 | `components/KuckitModuleRoute.tsx` | Renders module-registered routes  |
 
-## Adding Routes
-
-Create files in `src/routes/`:
-
-- `src/routes/about.tsx` → `/about`
-- `src/routes/users/$id.tsx` → `/users/:id`
-- `src/routes/settings/index.tsx` → `/settings`
-
-**File-based routes take precedence** over module-registered routes.
+## How It Works
 
-## Module Route Integration
-
-Modules register routes via `defineKuckitClientModule`. These are rendered via a catch-all pattern:
-
-1. Module registers route in `routes` array
-2. `RouteRegistry` collects routes during `loadKuckitClientModules()`
-3. Catch-all route (`$.tsx`) matches any unhandled path
-4. `KuckitModuleRoute` looks up path in registry and renders the component
+The web app uses `@kuckit/app-web` which provides a provider factory:
 
 ```tsx
-// routes/$.tsx - Catches module routes
-import { KuckitModuleRoute } from '@/components/KuckitModuleRoute'
-
-export function Route() {
-	return <KuckitModuleRoute />
-}
+// main.tsx
+import ReactDOM from 'react-dom/client'
+import { createKuckitWebProvider } from '@kuckit/app-web'
+import { routeTree } from './routeTree.gen'
+import { Route as rootRoute } from './routes/__root'
+import { getClientModuleSpecs } from './modules.client'
+import './index.css'
+
+const KuckitApp = createKuckitWebProvider({
+	serverUrl: import.meta.env.VITE_API_URL || 'http://localhost:3000',
+	modules: getClientModuleSpecs(),
+	env: import.meta.env.MODE,
+	routeTree,
+	rootRoute,
+})
+
+const rootEl = document.getElementById('app')!
+ReactDOM.createRoot(rootEl).render(<KuckitApp />)
 ```
 
-## Context Providers
-
-The app wraps content in Kuckit providers:
+The `@kuckit/app-web` package handles:
 
-```tsx
-<ServicesProvider>
-	{' '}
-	{/* RPC client, auth */}
-	<KuckitProvider>
-		{' '}
-		{/* Nav, slots, routes registries */}
-		<KuckitRpcProvider>
-			{' '}
-			{/* RPC context for modules */}
-			{children}
-		</KuckitRpcProvider>
-	</KuckitProvider>
-</ServicesProvider>
-```
+- RPC client and oRPC utils creation
+- React Query client setup
+- Better-Auth client integration
+- Module loading and route registration
+- Navigation and slot registries
+- Provider composition
 
-**Available hooks:**
+## Available Hooks
 
-- `useRpc<T>()` - Get typed RPC client for API calls
-- `useNavItems()` - Flat navigation items list
-- `useNavTree()` - Hierarchical navigation tree
-- `useSlot(name)` - Get components for a slot
-- `useHasSlot(name)` - Check if slot has content
+Import from `@kuckit/app-web`:
 
-## useRpc Hook
+- `useAuth()` - Auth client for sign in/out, session
+- `useRpc()` - Typed RPC client for API calls
+- `useOrpc()` - oRPC TanStack Query utils
+- `useQueryClient()` - React Query client
+- `useKuckitWeb()` - Full context with registries
 
-Module components must use `useRpc()` to access the API:
-
-```tsx
-import { useRpc } from '@kuckit/sdk-react'
-import { useQuery } from '@tanstack/react-query'
-
-interface MyRpc {
-	items: { list: (input: {}) => Promise<Item[]> }
-}
+## Adding Routes
 
-function MyComponent() {
-	const rpc = useRpc<MyRpc>()
+Create files in `src/routes/`:
 
-	const { data } = useQuery({
-		queryKey: ['items'],
-		queryFn: () => rpc.items.list({}),
-	})
-}
-```
+- `src/routes/about.tsx` → `/about`
+- `src/routes/users/$id.tsx` → `/users/:id`
+- `src/routes/settings/index.tsx` → `/settings`
 
-**Important**: Never use `import.meta.env.VITE_SERVER_URL` directly in module components - it's unavailable in external packages. The `useRpc` hook provides the correctly-configured client.
+**File-based routes take precedence** over module-registered routes.
 
-## Using Module UI Components
+## Adding Client Modules
 
-```tsx
-import { ItemsPage } from '@__APP_NAME_KEBAB__/items-module/ui'
+**`kuckit.config.ts` is the single source of truth for modules.**
 
-// In your route component
-export function Route() {
-	return <ItemsPage />
-}
-```
+1. Add to `kuckit.config.ts` (at project root):
 
-## Adding Client Modules
+   ```typescript
+   export default defineConfig({
+   	modules: [
+   		{ package: '@__APP_NAME_KEBAB__/items-module' },
+   		{ package: '@acme/billing-module' }, // Add new module here
+   	],
+   })
+   ```
 
-1. Import in `modules.client.ts`:
+2. Add import and mapping to `modules.client.ts`:
 
    ```typescript
-   import { kuckitClientModule as myClientModule } from '@__APP_NAME_KEBAB__/my-module/client'
-
-   export const clientModules = [
-   	itemsClientModule,
-   	myClientModule, // Add here
-   ]
+   import { kuckitClientModule as billingClientModule } from '@acme/billing-module/client'
+
+   const KNOWN_CLIENT_MODULES = {
+   	// ...existing
+   	'@acme/billing-module': {
+   		module: billingClientModule,
+   	},
+   }
    ```
 
+The CLI command `bunx kuckit add @acme/billing-module` automates both steps.
+
 ## Environment Variables
 
 See `.env.example` in this directory.

package/templates/base/apps/web/package.json

@@ -9,10 +9,8 @@
 		"check-types": "tsc --noEmit"
 	},
 	"dependencies": {
+		"@kuckit/app-web": "^2.0.0",
 		"@kuckit/sdk-react": "^2.0.0",
-		"@kuckit/auth": "^2.0.0",
-		"@orpc/client": "^1.10.0",
-		"@orpc/tanstack-query": "^1.10.0",
 		"@radix-ui/react-avatar": "^1.1.10",
 		"@radix-ui/react-collapsible": "^1.1.11",
 		"@radix-ui/react-dialog": "^1.1.14",
@@ -22,14 +20,12 @@
 		"@radix-ui/react-tooltip": "^1.2.7",
 		"@tanstack/react-query": "^5.0.0",
 		"@tanstack/react-router": "^1.114.0",
-		"better-auth": "^1.3.0",
 		"class-variance-authority": "^0.7.1",
 		"clsx": "^2.1.1",
 		"lucide-react": "^0.511.0",
 		"react": "^19.0.0",
 		"react-dom": "^19.0.0",
-		"tailwind-merge": "^3.0.0",
-		"zod": "^3.23.0"
+		"tailwind-merge": "^3.0.0"
 	},
 	"devDependencies": {
 		"@tailwindcss/vite": "^4.0.15",

package/templates/base/apps/web/src/components/KuckitModuleRoute.tsx

@@ -1,6 +1,5 @@
 import { useRouterState, Link, useNavigate } from '@tanstack/react-router'
-import { useKuckit } from '@/providers/KuckitProvider'
-import { useServices } from '@/providers/ServicesProvider'
+import { useKuckitWeb, useAuth } from '@kuckit/app-web'
 import { useEffect, useState } from 'react'
 
 /**
@@ -24,8 +23,8 @@ function isRootLevelRoute(path: string): boolean {
  * For root routes with meta.requiresAuth: true, redirects to /login if not authenticated.
  */
 export function KuckitModuleRoute() {
-	const { routeRegistry } = useKuckit()
-	const { authClient } = useServices()
+	const { routeRegistry } = useKuckitWeb()
+	const authClient = useAuth()
 	const { location } = useRouterState()
 	const navigate = useNavigate()
 	const pathname = location.pathname
@@ -47,11 +46,34 @@ export function KuckitModuleRoute() {
 	// For dashboard context, also try matching with /dashboard prefix stripped
 	const modulePathname = isDashboardContext ? pathname.replace('/dashboard', '') || '/' : pathname
 
-	// Find matching route
-	let routeDef = contextRoutes.find((r) => r.path === pathname)
+	// Match route path against pathname, supporting catch-all patterns like /docs/$
+	function matchRoute(routePath: string, pathname: string): boolean {
+		// Exact match
+		if (routePath === pathname) return true
+
+		// Catch-all pattern: /docs/$ matches /docs/anything/here
+		if (routePath.endsWith('/$')) {
+			const base = routePath.slice(0, -1) // Remove trailing $
+			return pathname.startsWith(base)
+		}
+
+		return false
+	}
+
+	// Find matching route - prefer exact matches over catch-all
+	const exactMatch = contextRoutes.find((r) => r.path === pathname)
+	const catchAllMatch = contextRoutes.find(
+		(r) => r.path.endsWith('/$') && matchRoute(r.path, pathname)
+	)
+	let routeDef = exactMatch || catchAllMatch
+
 	if (!routeDef && isDashboardContext) {
 		// For dashboard routes, also try matching stripped path
-		routeDef = contextRoutes.find((r) => r.path === modulePathname)
+		const exactDash = contextRoutes.find((r) => r.path === modulePathname)
+		const catchAllDash = contextRoutes.find(
+			(r) => r.path.endsWith('/$') && matchRoute(r.path, modulePathname)
+		)
+		routeDef = exactDash || catchAllDash
 	}
 
 	// Check auth for root routes with requiresAuth

package/templates/base/apps/web/src/components/dashboard/dashboard-overview.tsx

@@ -1,7 +1,7 @@
-import { useServices } from '@/providers/ServicesProvider'
+import { useAuth } from '@kuckit/app-web'
 
 export function DashboardOverview() {
-	const { authClient } = useServices()
+	const authClient = useAuth()
 	const { data: session } = authClient.useSession()
 
 	return (

package/templates/base/apps/web/src/components/dashboard/nav-user.tsx

@@ -1,6 +1,6 @@
 import { ChevronsUpDown, LogOut, User } from 'lucide-react'
 import { useNavigate } from '@tanstack/react-router'
-import { useServices } from '@/providers/ServicesProvider'
+import { useAuth } from '@kuckit/app-web'
 import {
 	DropdownMenu,
 	DropdownMenuContent,
@@ -19,7 +19,7 @@ import { Avatar, AvatarFallback, AvatarImage } from '@/components/ui/avatar'
 export function NavUser() {
 	const { isMobile } = useSidebar()
 	const navigate = useNavigate()
-	const { authClient } = useServices()
+	const authClient = useAuth()
 	const { data: session } = authClient.useSession()
 
 	const user = session?.user

package/templates/base/apps/web/src/main.tsx

@@ -1,27 +1,17 @@
-import { createRouter } from '@tanstack/react-router'
 import ReactDOM from 'react-dom/client'
+import { createKuckitWebProvider } from '@kuckit/app-web'
 import { routeTree } from './routeTree.gen'
-import { ServicesProvider } from './providers/ServicesProvider'
-import { KuckitProvider } from './providers/KuckitProvider'
+import { Route as rootRoute } from './routes/__root'
+import { getClientModuleSpecs } from './modules.client'
 import './index.css'
 
-declare module '@tanstack/react-router' {
-	interface Register {
-		router: ReturnType<typeof createRouter<typeof routeTree>>
-	}
-}
+const KuckitApp = createKuckitWebProvider({
+	serverUrl: import.meta.env.VITE_API_URL || 'http://localhost:3000',
+	modules: getClientModuleSpecs(),
+	env: import.meta.env.MODE,
+	routeTree,
+	rootRoute,
+})
 
-const rootElement = document.getElementById('app')
-
-if (!rootElement) {
-	throw new Error('Root element not found')
-}
-
-if (!rootElement.innerHTML) {
-	const root = ReactDOM.createRoot(rootElement)
-	root.render(
-		<ServicesProvider>
-			<KuckitProvider />
-		</ServicesProvider>
-	)
-}
+const rootEl = document.getElementById('app')!
+ReactDOM.createRoot(rootEl).render(<KuckitApp />)

package/templates/base/apps/web/src/modules.client.ts

@@ -1,17 +1,51 @@
 import type { ClientModuleSpec } from '@kuckit/sdk-react'
 import { kuckitClientModule as itemsClientModule } from '@__APP_NAME_KEBAB__/items-module/client'
+import config from '../../../kuckit.config'
 
 /**
- * Client modules configuration
+ * Known client modules mapping: package name → direct module import
  *
- * Modules installed via 'kuckit add' will be added here automatically.
+ * This enables config-driven module loading while keeping direct imports
+ * for workspace packages (required for Vite bundling).
+ *
+ * When adding a new module:
+ * 1. Add to kuckit.config.ts (source of truth)
+ * 2. Add import and mapping here
  */
-export const getClientModuleSpecs = (): ClientModuleSpec[] => {
-	const modules: ClientModuleSpec[] = [
-		// KUCKIT_CLIENT_MODULES_START
-		{ module: itemsClientModule },
-		// KUCKIT_CLIENT_MODULES_END
-	]
+const KNOWN_CLIENT_MODULES: Record<string, { module: unknown }> = {
+	// KUCKIT_KNOWN_CLIENT_MODULES_START
+	'@__APP_NAME_KEBAB__/items-module': {
+		module: itemsClientModule,
+	},
+	// KUCKIT_KNOWN_CLIENT_MODULES_END
+}
+
+/**
+ * Convert unified config to ClientModuleSpec array.
+ * For known modules, uses direct imports. For npm packages, uses package-based loading.
+ */
+function configToClientModuleSpecs(): ClientModuleSpec[] {
+	return config.modules
+		.filter((m) => m.enabled !== false)
+		.map((m) => {
+			const known = KNOWN_CLIENT_MODULES[m.package]
+			if (known) {
+				return {
+					module: known.module,
+					config: m.config,
+				} as ClientModuleSpec
+			}
+			// For npm packages, use package-based loading (client subpath)
+			return {
+				package: `${m.package}/client`,
+				config: m.config,
+			} as ClientModuleSpec
+		})
+}
 
-	return modules
+/**
+ * Get client module specs from kuckit.config.ts (single source of truth).
+ */
+export const getClientModuleSpecs = (): ClientModuleSpec[] => {
+	return configToClientModuleSpecs()
 }

package/templates/base/apps/web/src/routes/__root.tsx

@@ -1,6 +1,6 @@
 import type { QueryClient } from '@tanstack/react-query'
 import { Outlet, createRootRouteWithContext } from '@tanstack/react-router'
-import type { ORPCUtils } from '../services/types'
+import type { ORPCUtils } from '@kuckit/app-web'
 
 export interface RouterAppContext {
 	orpc: ORPCUtils

package/templates/base/apps/web/src/routes/dashboard.tsx

@@ -1,6 +1,6 @@
 import { createFileRoute, Outlet, redirect } from '@tanstack/react-router'
 import { DashboardLayout } from '@/components/dashboard/dashboard-layout'
-import { createAuthClientService } from '../services/auth-client'
+import { createAuthClientService } from '@kuckit/app-web'
 
 export const Route = createFileRoute('/dashboard')({
 	beforeLoad: async () => {

package/templates/base/apps/web/src/routes/index.tsx

@@ -1,12 +1,12 @@
 import { createFileRoute, Link } from '@tanstack/react-router'
-import { useServices } from '../providers/ServicesProvider'
+import { useAuth } from '@kuckit/app-web'
 
 export const Route = createFileRoute('/')({
 	component: HomePage,
 })
 
 function HomePage() {
-	const { authClient } = useServices()
+	const authClient = useAuth()
 	const { data: session, isPending } = authClient.useSession()
 
 	if (isPending) {

package/templates/base/apps/web/src/routes/login.tsx

@@ -1,13 +1,13 @@
 import { createFileRoute, useNavigate } from '@tanstack/react-router'
 import { useState } from 'react'
-import { useServices } from '../providers/ServicesProvider'
+import { useAuth } from '@kuckit/app-web'
 
 export const Route = createFileRoute('/login')({
 	component: LoginPage,
 })
 
 function LoginPage() {
-	const { authClient } = useServices()
+	const authClient = useAuth()
 	const navigate = useNavigate()
 	const [isSignUp, setIsSignUp] = useState(false)
 	const [email, setEmail] = useState('')

package/templates/base/drizzle.config.ts

@@ -2,6 +2,7 @@ import { defineConfig } from 'drizzle-kit'
 import dotenv from 'dotenv'
 import { dirname, resolve } from 'path'
 import { fileURLToPath } from 'url'
+import { getModuleSchemaPaths } from '@kuckit/db/schema-discovery'
 
 const currentFilePath = fileURLToPath(import.meta.url)
 const currentDirPath = dirname(currentFilePath)
@@ -26,12 +27,7 @@ function buildDatabaseUrl(): string {
 }
 
 export default defineConfig({
-	schema: [
-		// Auth schema from @kuckit/db (resolved from node_modules)
-		'./node_modules/@kuckit/db/dist/schema/auth.js',
-		// Local module schemas
-		resolve(currentDirPath, './packages/items-module/src/adapters'),
-	],
+	schema: getModuleSchemaPaths(),
 	out: './drizzle',
 	dialect: 'postgresql',
 	dbCredentials: { url: buildDatabaseUrl() },

package/templates/base/kuckit.config.ts

@@ -0,0 +1,30 @@
+import { defineConfig } from '@kuckit/sdk/config'
+
+/**
+ * Kuckit Configuration
+ *
+ * This is the unified configuration file for both server and client modules.
+ * Both apps/server and apps/web will read from this single source of truth.
+ *
+ * @see https://github.com/kuckit/kuckit#configuration
+ */
+export default defineConfig({
+	modules: [
+		// KUCKIT_MODULES_START
+		{ package: '@__APP_NAME_KEBAB__/items-module', schemaDir: 'src/adapters' },
+		// KUCKIT_MODULES_END
+	],
+
+	server: {
+		apiPrefix: '/api',
+	},
+
+	client: {
+		routeInjection: true,
+		componentRegistry: 'context',
+	},
+
+	discovery: {
+		enabled: false,
+	},
+})

package/templates/base/packages/items-module/AGENTS.md

@@ -208,3 +208,86 @@ export function ItemsPage() {
 ```
 
 **Important**: Never use `import.meta.env` directly in module components - use `useRpc()` instead. Module packages are bundled separately and don't have access to the host app's environment variables.
+
+<!-- MCP_AGENT_MAIL_AND_BEADS_SNIPPET_START -->
+
+## MCP Agent Mail: coordination for multi-agent workflows
+
+What it is
+
+- A mail-like layer that lets coding agents coordinate asynchronously via MCP tools and resources.
+- Provides identities, inbox/outbox, searchable threads, and advisory file reservations, with human-auditable artifacts in Git.
+
+Why it's useful
+
+- Prevents agents from stepping on each other with explicit file reservations (leases) for files/globs.
+- Keeps communication out of your token budget by storing messages in a per-project archive.
+- Offers quick reads (`resource://inbox/...`, `resource://thread/...`) and macros that bundle common flows.
+
+How to use effectively
+
+1. Same repository
+   - Register an identity: call `ensure_project`, then `register_agent` using this repo's absolute path as `project_key`.
+   - Reserve files before you edit: `file_reservation_paths(project_key, agent_name, ["src/**"], ttl_seconds=3600, exclusive=true)` to signal intent and avoid conflict.
+   - Communicate with threads: use `send_message(..., thread_id="FEAT-123")`; check inbox with `fetch_inbox` and acknowledge with `acknowledge_message`.
+   - Read fast: `resource://inbox/{Agent}?project=<abs-path>&limit=20` or `resource://thread/{id}?project=<abs-path>&include_bodies=true`.
+   - Tip: set `AGENT_NAME` in your environment so the pre-commit guard can block commits that conflict with others' active exclusive file reservations.
+
+2. Across different repos in one project (e.g., Next.js frontend + FastAPI backend)
+   - Option A (single project bus): register both sides under the same `project_key` (shared key/path). Keep reservation patterns specific (e.g., `frontend/**` vs `backend/**`).
+   - Option B (separate projects): each repo has its own `project_key`; use `macro_contact_handshake` or `request_contact`/`respond_contact` to link agents, then message directly. Keep a shared `thread_id` (e.g., ticket key) across repos for clean summaries/audits.
+
+Macros vs granular tools
+
+- Prefer macros when you want speed or are on a smaller model: `macro_start_session`, `macro_prepare_thread`, `macro_file_reservation_cycle`, `macro_contact_handshake`.
+- Use granular tools when you need control: `register_agent`, `file_reservation_paths`, `send_message`, `fetch_inbox`, `acknowledge_message`.
+
+Common pitfalls
+
+- "from_agent not registered": always `register_agent` in the correct `project_key` first.
+- "FILE_RESERVATION_CONFLICT": adjust patterns, wait for expiry, or use a non-exclusive reservation when appropriate.
+- Auth errors: if JWT+JWKS is enabled, include a bearer token with a `kid` that matches server JWKS; static bearer is used only when JWT is disabled.
+
+## Integrating with Beads (dependency-aware task planning)
+
+Beads provides a lightweight, dependency-aware issue database and a CLI (`bd`) for selecting "ready work," setting priorities, and tracking status. It complements MCP Agent Mail's messaging, audit trail, and file-reservation signals. Project: [steveyegge/beads](https://github.com/steveyegge/beads)
+
+Recommended conventions
+
+- **Single source of truth**: Use **Beads** for task status/priority/dependencies; use **Agent Mail** for conversation, decisions, and attachments (audit).
+- **Shared identifiers**: Use the Beads issue id (e.g., `bd-123`) as the Mail `thread_id` and prefix message subjects with `[bd-123]`.
+- **Reservations**: When starting a `bd-###` task, call `file_reservation_paths(...)` for the affected paths; include the issue id in the `reason` and release on completion.
+
+Typical flow (agents)
+
+1. **Pick ready work** (Beads)
+   - `bd ready --json` → choose one item (highest priority, no blockers)
+2. **Reserve edit surface** (Mail)
+   - `file_reservation_paths(project_key, agent_name, ["src/**"], ttl_seconds=3600, exclusive=true, reason="bd-123")`
+3. **Announce start** (Mail)
+   - `send_message(..., thread_id="bd-123", subject="[bd-123] Start: <short title>", ack_required=true)`
+4. **Work and update**
+   - Reply in-thread with progress and attach artifacts/images; keep the discussion in one thread per issue id
+5. **Complete and release**
+   - `bd close bd-123 --reason "Completed"` (Beads is status authority)
+   - `release_file_reservations(project_key, agent_name, paths=["src/**"])`
+   - Final Mail reply: `[bd-123] Completed` with summary and links
+
+Mapping cheat-sheet
+
+- **Mail `thread_id`** ↔ `bd-###`
+- **Mail subject**: `[bd-###] …`
+- **File reservation `reason`**: `bd-###`
+- **Commit messages (optional)**: include `bd-###` for traceability
+
+Event mirroring (optional automation)
+
+- On `bd update --status blocked`, send a high-importance Mail message in thread `bd-###` describing the blocker.
+- On Mail "ACK overdue" for a critical decision, add a Beads label (e.g., `needs-ack`) or bump priority to surface it in `bd ready`.
+
+Pitfalls to avoid
+
+- Don't create or manage tasks in Mail; treat Beads as the single task queue.
+- Always include `bd-###` in message `thread_id` to avoid ID drift across tools.
+
+<!-- MCP_AGENT_MAIL_AND_BEADS_SNIPPET_END -->

package/templates/base/apps/server/src/app.ts

@@ -1,20 +0,0 @@
-import express, { type Express } from 'express'
-import cors from 'cors'
-
-/**
- * Create and configure Express app
- */
-export const createApp = (): Express => {
-	const app = express()
-
-	app.use(
-		cors({
-			origin: process.env.CORS_ORIGIN || 'http://localhost:3001',
-			methods: ['GET', 'POST', 'OPTIONS'],
-			allowedHeaders: ['Content-Type', 'Authorization'],
-			credentials: true,
-		})
-	)
-
-	return app
-}

package/templates/base/apps/server/src/auth.ts

@@ -1,10 +0,0 @@
-import { auth } from '@kuckit/auth'
-import { toNodeHandler } from 'better-auth/node'
-import type { Express } from 'express'
-
-/**
- * Setup Better-Auth routes
- */
-export const setupAuth = (app: Express) => {
-	app.all('/api/auth{/*path}', toNodeHandler(auth))
-}

package/templates/base/apps/server/src/config/modules.ts

@@ -1,21 +0,0 @@
-import type { ModuleSpec } from '@kuckit/sdk'
-import { kuckitModule as itemsModule } from '@__APP_NAME_KEBAB__/items-module'
-
-/**
- * Module specifications for the server application
- *
- * Add modules here to configure the server's functionality.
- * Modules are loaded in order, with dependencies resolved automatically.
- *
- * IMPORTANT: Server and client modules must be kept in sync!
- * If you add/remove a module here, also update apps/web/src/modules.client.ts
- */
-export const getModuleSpecs = (): ModuleSpec[] => {
-	const modules: ModuleSpec[] = [
-		// KUCKIT_SERVER_MODULES_START
-		{ module: itemsModule },
-		// KUCKIT_SERVER_MODULES_END
-	]
-
-	return modules
-}