diff --git a/apps/api/package.json b/apps/api/package.json
index 560cc3e7b..205f99d21 100644
--- a/apps/api/package.json
+++ b/apps/api/package.json
@@ -24,6 +24,7 @@
"react": "^19.2.5",
"react-dom": "^19.2.5",
"use-intl": "^4.11.0",
+ "ws": "^8.21.0",
"zod": "^4.4.1"
},
"devDependencies": {
@@ -32,8 +33,10 @@
"@types/node": "^25.6.0",
"@types/react": "^19.2.14",
"@types/react-dom": "^19.2.3",
+ "@types/ws": "^8.18.1",
"@vitnode/config": "workspace:*",
"@vitnode/nodemailer": "workspace:*",
+ "@vitnode/blog": "workspace:*",
"dotenv": "^17.4.2",
"eslint": "^10.2.1",
"react-email": "^6.1.5",
diff --git a/apps/api/src/index.ts b/apps/api/src/index.ts
index 62084e46c..363476bdc 100644
--- a/apps/api/src/index.ts
+++ b/apps/api/src/index.ts
@@ -1,6 +1,8 @@
-import { serve } from "@hono/node-server";
+import { serve, upgradeWebSocket } from "@hono/node-server";
import { OpenAPIHono } from "@hono/zod-openapi";
import { VitNodeAPI } from "@vitnode/core/api/config";
+import { handleVitNodeWebSocket } from "@vitnode/core/ws/handle";
+import { WebSocketServer } from "ws";
import { vitNodeApiConfig } from "./vitnode.api.config.js";
@@ -11,10 +13,17 @@ VitNodeAPI({
vitNodeApiConfig,
});
+const wss = new WebSocketServer({ noServer: true });
+
+app.get("/ws", upgradeWebSocket(handleVitNodeWebSocket()));
+
serve(
{
fetch: app.fetch,
port: 8080,
+ websocket: {
+ server: wss,
+ },
},
info => {
const initMessage = "\x1b[34m[VitNode]\x1b[0m";
diff --git a/apps/api/src/vitnode.api.config.ts b/apps/api/src/vitnode.api.config.ts
index 29274f43b..eb918358b 100644
--- a/apps/api/src/vitnode.api.config.ts
+++ b/apps/api/src/vitnode.api.config.ts
@@ -1,3 +1,4 @@
+import { blogApiPlugin } from "@vitnode/blog/config.api";
import { buildApiConfig } from "@vitnode/core/vitnode.config";
import { NodemailerEmailAdapter } from "@vitnode/nodemailer";
import { config } from "dotenv";
@@ -11,7 +12,7 @@ export const POSTGRES_URL =
process.env.POSTGRES_URL ?? "postgresql://root:root@localhost:5432/vitnode";
export const vitNodeApiConfig = buildApiConfig({
- plugins: [],
+ plugins: [blogApiPlugin()],
pathToMessages: async path => await import(`./locales/${path}`),
dbProvider: drizzle({
connection: POSTGRES_URL,
diff --git a/apps/docs/content/docs/dev/meta.json b/apps/docs/content/docs/dev/meta.json
index 86c671ceb..69c79a5ff 100644
--- a/apps/docs/content/docs/dev/meta.json
+++ b/apps/docs/content/docs/dev/meta.json
@@ -19,6 +19,7 @@
"email",
"sso",
"cron",
+ "websocket",
"---Frontend---",
"layouts-and-pages",
"admin-page",
diff --git a/apps/docs/content/docs/dev/redis.mdx b/apps/docs/content/docs/dev/redis.mdx
new file mode 100644
index 000000000..ef08ba8cb
--- /dev/null
+++ b/apps/docs/content/docs/dev/redis.mdx
@@ -0,0 +1,15 @@
+---
+title: Redis
+description: Enhance your application's performance and scalability.
+---
+
+
+ We're working hard to bring you the best documentation experience.
+
+
+## Going to production - websockets
+
+The connection list lives in memory on a single server. If you run **several
+server instances** behind a load balancer, a `broadcast` or `sendToUser` only
+reaches the clients on the same instance. To fix that, share the messages
+between instances with a pub/sub like **Redis**.
diff --git a/apps/docs/content/docs/dev/websocket.mdx b/apps/docs/content/docs/dev/websocket.mdx
new file mode 100644
index 000000000..d2146f5ab
--- /dev/null
+++ b/apps/docs/content/docs/dev/websocket.mdx
@@ -0,0 +1,353 @@
+---
+title: WebSocket
+description: Add real-time features — live updates and notifications — with one shared connection.
+---
+
+import { Tab, Tabs } from "fumadocs-ui/components/tabs";
+
+| Cloud | Self-Hosted | Links |
+| ---------------- | ------------ | ---------------------------------------------------------------- |
+| ❌ Not Supported | ✅ Supported | [Hono WebSocket Helper](https://hono.dev/docs/helpers/websocket) |
+
+A normal request works one way: the browser asks, the server answers, done. A
+**WebSocket** keeps the line open both ways, so the server can push data to the
+browser the moment something happens — no refreshing, no polling.
+
+Use it for things that should feel instant: live lists, presence, chat, and
+notifications.
+
+## How it works
+
+VitNode takes care of the tricky parts for you:
+
+- **One connection.** The browser opens a single socket at `/ws`, and every
+ feature shares it. You never manage sockets by hand.
+- **Channels.** Each message is tagged with a channel id so it reaches the
+ right place. An id looks like `{pluginId}_{module}_{name}`.
+- **Shared across tabs.** Open your app in five tabs and there is still just
+ **one** connection. One tab becomes the "leader" and the others ride along,
+ so every tab sees the same messages with no duplicates.
+- **Knows who is signed in.** The connection is tied to the logged-in user. It
+ automatically re-connects when they sign in or out, dropping to a "guest"
+ connection on sign-out.
+
+
+ The client provider is already mounted for you in the root layout, so the
+ connection is live on every page — there is nothing to wire up on the
+ frontend.
+
+
+## Setup
+
+You only do this once, in your API entrypoint.
+
+
+
+### Add the WebSocket server
+
+The socket is served by your runtime, so install it there.
+
+
+
+
+
+Install the `ws` package:
+
+```bash title="Terminal"
+pnpm add ws && pnpm add -D @types/ws
+```
+
+```ts title="src/index.ts"
+import { serve } from "@hono/node-server";
+import { WebSocketServer } from "ws";
+
+const wss = new WebSocketServer({ noServer: true });
+
+serve({
+ fetch: app.fetch,
+ port: 8080,
+ websocket: { server: wss }, // [!code ++]
+});
+```
+
+
+
+
+
+Bun has WebSockets built in:
+
+```ts title="src/index.ts"
+import { websocket } from "hono/bun";
+
+export default {
+ fetch: app.fetch,
+ websocket, // [!code ++]
+};
+```
+
+
+
+
+
+
+
+### Add the handler
+
+`handleVitNodeWebSocket` wires the connection into VitNode. It is the same on
+every runtime — only the `upgradeWebSocket` import differs.
+
+
+
+```ts title="src/index.ts" tab="Node.js"
+import { serve, upgradeWebSocket } from "@hono/node-server"; // [!code ++]
+import { handleVitNodeWebSocket } from "@vitnode/core/ws/handle"; // [!code ++]
+
+app.get("/ws", upgradeWebSocket(handleVitNodeWebSocket())); // [!code ++]
+```
+
+```ts title="src/index.ts" tab="Bun"
+import { upgradeWebSocket, websocket } from "hono/bun"; // [!code ++]
+import { handleVitNodeWebSocket } from "@vitnode/core/ws/handle"; // [!code ++]
+
+app.get("/ws", upgradeWebSocket(handleVitNodeWebSocket())); // [!code ++]
+```
+
+
+
+That's it — your app now has real-time. Next, let's send a message.
+
+
+
+
+## Send and receive
+
+Let's build a tiny **echo**: the client sends a message, the server sends it
+right back. It shows the full round-trip in four small steps.
+
+
+
+### Describe the messages (the channel)
+
+A **channel** is a shared contract: it holds the id and the two message
+types — what the client **sends** and what it **receives**. Put it in its own
+file so both the server and the client can import it.
+
+```ts title="realtime/echo.channel.ts"
+import { createWebSocketChannel } from "@vitnode/core/ws/types";
+
+import { CONFIG_PLUGIN } from "@/const";
+
+export interface EchoClientMessage {
+ message: string;
+}
+
+export interface EchoServerMessage {
+ reply: string;
+}
+
+// Full id: `@vitnode/blog_chat_echo`
+export const echoChannel = createWebSocketChannel<
+ EchoClientMessage, // what the client sends
+ EchoServerMessage // what the client gets back
+>({
+ pluginId: CONFIG_PLUGIN.pluginId,
+ module: "chat",
+ id: "echo",
+});
+```
+
+
+
+### Handle it on the server
+
+`buildWebSocket` runs your `onMessage` whenever a client sends to this channel.
+You get `data` (already parsed and typed) and `send` to reply on the same
+channel. You also get `c` — the same context as a route, so you can reach the
+database, the user, the logger, and more.
+
+```ts title="api/modules/chat/echo.ws.ts"
+import { buildWebSocket } from "@vitnode/core/api/lib/websocket";
+
+import type {
+ EchoClientMessage,
+ EchoServerMessage,
+} from "@/realtime/echo.channel";
+
+export const echoWebSocket = buildWebSocket<
+ EchoClientMessage,
+ EchoServerMessage
+>({
+ id: "echo",
+ description: "Replies with whatever it receives.",
+ onMessage: ({ data, send }) => {
+ send({ reply: `You said: ${data.message}` });
+ },
+});
+```
+
+
+
+### Register it in a module
+
+Add it to the module's `webSockets`, the same way you add routes.
+
+```ts title="api/modules/chat/chat.module.ts"
+import { buildModule } from "@vitnode/core/api/lib/module";
+
+import { CONFIG_PLUGIN } from "@/const";
+
+import { echoWebSocket } from "./echo.ws"; // [!code ++]
+
+export const chatModule = buildModule({
+ pluginId: CONFIG_PLUGIN.pluginId,
+ name: "chat",
+ routes: [],
+ webSockets: [echoWebSocket], // [!code ++]
+});
+```
+
+
+
+### Use it in a component
+
+`useVitNodeWebSocket` connects the component to the channel. Because it knows
+the channel, `send` and the `onMessage` `data` are fully typed — no casting.
+
+```tsx title="views/echo.tsx"
+"use client";
+
+import { useVitNodeWebSocket } from "@vitnode/core/ws/use-websocket";
+import React from "react";
+
+import { echoChannel } from "@/realtime/echo.channel";
+
+export const Echo = () => {
+ const [reply, setReply] = React.useState("");
+
+ const { send, readyState } = useVitNodeWebSocket(echoChannel, {
+ onMessage: data => setReply(data.reply), // data is EchoServerMessage
+ });
+
+ return (
+
+ );
+};
+```
+
+
+
+
+
+ The subscription lives with the component: it starts on mount and stops on
+ unmount. So a view only receives messages while it is on screen — leave the
+ page and it goes quiet on its own.
+
+
+## Broadcast to everyone
+
+Want to push the same update to **every** open browser? Use `broadcast` from any
+route or handler. A great use is keeping a list fresh: broadcast whenever the
+data changes, and every client refreshes.
+
+First, a "broadcast-only" channel. Since clients never send to it, its send type
+is `never`:
+
+```ts title="realtime/posts.channel.ts"
+import { createWebSocketChannel } from "@vitnode/core/ws/types";
+
+import { CONFIG_PLUGIN } from "@/const";
+
+export interface PostsChange {
+ action: "created" | "deleted" | "updated";
+}
+
+export const postsChannel = createWebSocketChannel({
+ pluginId: CONFIG_PLUGIN.pluginId,
+ module: "posts",
+ id: "changes",
+});
+```
+
+Then broadcast after you change something. The payload is type-checked against
+the channel:
+
+```ts title="api/modules/posts/routes/create.route.ts"
+import { postsChannel } from "@/realtime/posts.channel";
+
+// ...inside the handler, after creating the post:
+c.get("realtime").broadcast(postsChannel, { action: "created" });
+```
+
+On the client, listen and refresh the page when it fires:
+
+```tsx title="views/live-posts.tsx"
+"use client";
+
+import { useRouter } from "@vitnode/core/lib/navigation";
+import { useVitNodeWebSocket } from "@vitnode/core/ws/use-websocket";
+
+import { postsChannel } from "@/realtime/posts.channel";
+
+export const LivePosts = () => {
+ const router = useRouter();
+
+ useVitNodeWebSocket(postsChannel, {
+ onMessage: () => router.refresh(),
+ });
+
+ return null;
+};
+```
+
+
+ `broadcast` reaches everyone, so use it only for non-sensitive signals like
+ "the list changed". For private data, send to one user instead (below).
+
+
+## Send to one user
+
+To reach **one person** — on every browser where they are signed in — use
+`sendToUser`. VitNode knows which user owns each connection (from their sign-in
+cookie), so the message never leaks to anyone else.
+
+This powers the built-in notification system. Send one from any handler:
+
+```ts title="server: notify a user"
+import { notificationsChannel } from "@vitnode/core/ws/notifications";
+
+c.get("realtime").sendToUser(userId, notificationsChannel, {
+ title: "Welcome back 👋",
+ description: "You have 3 new messages.",
+ type: "info",
+});
+```
+
+Show it however you like — here as a toast with `sonner`:
+
+```tsx title="notification-listener.tsx"
+"use client";
+
+import { notificationsChannel } from "@vitnode/core/ws/notifications";
+import { useVitNodeWebSocket } from "@vitnode/core/ws/use-websocket";
+import { toast } from "sonner";
+
+export const NotificationListener = () => {
+ useVitNodeWebSocket(notificationsChannel, {
+ onMessage: n => toast(n.title, { description: n.description }),
+ });
+
+ return null;
+};
+```
+
+
+ The notification channel, this listener, and an admin dashboard button to send
+ one are all built in. A user only receives notifications while signed in — a
+ guest connection has no one to deliver to.
+
diff --git a/packages/vitnode/src/api/lib/module.ts b/packages/vitnode/src/api/lib/module.ts
index 79c239f63..30af2f7af 100644
--- a/packages/vitnode/src/api/lib/module.ts
+++ b/packages/vitnode/src/api/lib/module.ts
@@ -2,6 +2,7 @@ import { OpenAPIHono } from "@hono/zod-openapi";
import type { BuildCronReturn } from "./cron";
import type { Route } from "./route";
+import type { BuildWebSocketReturn } from "./websocket";
export interface BuildModuleType {
plugin: Plugin;
@@ -19,6 +20,7 @@ export interface BaseBuildModuleReturn<
name: M;
pluginId: P;
routes: Routes;
+ webSockets: BuildWebSocketReturn[];
}
export interface BuildModuleReturn<
@@ -41,12 +43,14 @@ export function buildModule<
name,
modules,
cronJobs = [],
+ webSockets = [],
}: {
cronJobs?: BuildCronReturn[];
modules?: Modules;
name: M;
pluginId: P;
routes: Routes;
+ webSockets?: BuildWebSocketReturn[];
}): BuildModuleReturn {
const hono = new OpenAPIHono();
@@ -62,5 +66,5 @@ export function buildModule<
});
}
- return { routes, pluginId, hono, name, modules, cronJobs };
+ return { routes, pluginId, hono, name, modules, cronJobs, webSockets };
}
diff --git a/packages/vitnode/src/api/lib/plugin.ts b/packages/vitnode/src/api/lib/plugin.ts
index 1e4c5b2e2..8c27aaf76 100644
--- a/packages/vitnode/src/api/lib/plugin.ts
+++ b/packages/vitnode/src/api/lib/plugin.ts
@@ -2,6 +2,7 @@ import { OpenAPIHono } from "@hono/zod-openapi";
import type { CronJobConfig } from "./cron";
import type { BuildModuleReturn } from "./module";
+import type { WebSocketConfig } from "./websocket";
import { checkPluginId } from "./check-plugin-id";
@@ -9,6 +10,7 @@ export interface BuildPluginApiReturn {
cronJobs: Omit[];
hono: OpenAPIHono;
pluginId: string;
+ webSockets: Omit[];
}
export function buildApiPlugin
({
@@ -23,17 +25,23 @@ export function buildApiPlugin
({
const hono = new OpenAPIHono();
const cronJobs: BuildPluginApiReturn["cronJobs"] = [];
+ const webSockets: BuildPluginApiReturn["webSockets"] = [];
modules.forEach(handler => {
hono.route(`/${handler.name}`, handler.hono);
handler.cronJobs?.forEach(cron => {
cronJobs.push({ ...cron, module: handler.name });
});
+
+ handler.webSockets?.forEach(webSocket => {
+ webSockets.push({ ...webSocket, module: handler.name });
+ });
});
return {
pluginId,
hono,
cronJobs,
+ webSockets,
};
}
diff --git a/packages/vitnode/src/api/lib/websocket.ts b/packages/vitnode/src/api/lib/websocket.ts
new file mode 100644
index 000000000..e60ed6b27
--- /dev/null
+++ b/packages/vitnode/src/api/lib/websocket.ts
@@ -0,0 +1,66 @@
+import type { Context } from "hono";
+import type { WSContext } from "hono/ws";
+
+import type { EnvVitNode } from "../middlewares/global.middleware";
+
+export { getWebSocketId } from "@/ws/types";
+
+/**
+ * WebSocket context for controlling the connection. Use it to `send`, `close`
+ * or read the `readyState`. The underlying runtime socket is exposed on
+ * `ws.raw` and is left generic so the same handler works across runtimes
+ * (node.js `ws`, Bun, ...).
+ */
+export type VitNodeWSContext = WSContext;
+
+/**
+ * Arguments passed to a registered WebSocket's `onMessage` handler.
+ *
+ * - `TReceive` - the payload the client sends for this socket.
+ * - `TSend` - the payload the server sends back to the client.
+ */
+export interface VitNodeWSMessageParams {
+ /** Hono request context - reach the db, the user, the logger, etc. */
+ c: Context;
+ /** The payload sent by the client for this socket. */
+ data: TReceive;
+ /** Send a payload back to this client on the same socket id. */
+ send: (data: TSend) => void;
+ /** Low-level WebSocket context (`send`, `close`, `readyState`, ...). */
+ ws: VitNodeWSContext;
+}
+
+/**
+ * A registered WebSocket. The generic argument types are only used at the
+ * definition site (via {@link buildWebSocket}); once stored they are erased so
+ * sockets with different message shapes can live in the same array.
+ */
+export interface BuildWebSocketReturn {
+ description?: string;
+ /**
+ * The part of the id chosen by the developer. The full id a client targets
+ * is `{pluginId}_{module}_{id}`.
+ */
+ id: string;
+ onMessage: (params: VitNodeWSMessageParams) => Promise | void;
+}
+
+/**
+ * A registered WebSocket together with the plugin and module it belongs to.
+ * The `module` is filled in when the module is built and the `pluginId` when
+ * the plugin is built, mirroring how cron jobs are wired up.
+ */
+export interface WebSocketConfig extends BuildWebSocketReturn {
+ module: string;
+ pluginId: string;
+}
+
+export function buildWebSocket(webSocket: {
+ description?: string;
+ id: string;
+ onMessage: (
+ params: VitNodeWSMessageParams,
+ ) => Promise | void;
+}): BuildWebSocketReturn {
+ return webSocket as BuildWebSocketReturn;
+}
diff --git a/packages/vitnode/src/api/middlewares/global.middleware.ts b/packages/vitnode/src/api/middlewares/global.middleware.ts
index 981300229..9c7bc2b01 100644
--- a/packages/vitnode/src/api/middlewares/global.middleware.ts
+++ b/packages/vitnode/src/api/middlewares/global.middleware.ts
@@ -3,13 +3,16 @@ import type { Context, Env, Next } from "hono";
import { HTTPException } from "hono/http-exception";
import type { VitNodeApiConfig, VitNodeConfig } from "@/vitnode.config";
+import type { VitNodeRealtime } from "@/ws/registry";
import { EmailModel, type EmailModelSendArgs } from "@/api/models/email";
import { SessionModel } from "@/api/models/session";
import { SessionAdminModel } from "@/api/models/session-admin";
import { CONFIG } from "@/lib/config";
+import { realtime } from "@/ws/registry";
import type { BuildCronReturn } from "../lib/cron";
+import type { WebSocketConfig } from "../lib/websocket";
import type { SSOApiPlugin } from "../models/sso";
import {
@@ -62,6 +65,7 @@ export interface EnvVariablesVitNode {
};
pathToMessages: (path: string) => Promise<{ default: object }>;
plugins: { id: string }[];
+ webSockets: WebSocketConfig[];
};
db: Pick["dbProvider"];
email: {
@@ -72,6 +76,7 @@ export interface EnvVariablesVitNode {
plugin: {
id: string;
};
+ realtime: VitNodeRealtime;
user: null | {
avatarColor: string;
birthday: Date | null;
@@ -119,6 +124,13 @@ export const globalMiddleware = ({
})),
);
+ const webSocketsMetadata: WebSocketConfig[] = plugins.flatMap(plugin =>
+ plugin.webSockets.map(webSocket => ({
+ ...webSocket,
+ pluginId: plugin.pluginId,
+ })),
+ );
+
const ipHeaderKeys = [
"x-forwarded-for",
"x-real-ip",
@@ -154,6 +166,7 @@ export const globalMiddleware = ({
c.set("ipAddress", ipAddress ?? "127.0.0.1");
c.set("db", dbProvider);
c.set("email", new EmailModel(c));
+ c.set("realtime", realtime);
c.set("core", {
pathToMessages,
@@ -176,6 +189,7 @@ export const globalMiddleware = ({
cronSecret: CONFIG.cronJobSecret,
plugins: pluginsMetadata,
cron: cronMetadata,
+ webSockets: webSocketsMetadata,
});
const user = await new SessionModel(c).getUser();
diff --git a/packages/vitnode/src/api/modules/admin/admin.module.ts b/packages/vitnode/src/api/modules/admin/admin.module.ts
index 2c9e61ea4..8f56c4612 100644
--- a/packages/vitnode/src/api/modules/admin/admin.module.ts
+++ b/packages/vitnode/src/api/modules/admin/admin.module.ts
@@ -3,13 +3,14 @@ import { CONFIG_PLUGIN } from "@/config";
import { advancedAdminModule } from "./advanced/advanced.admin.module";
import { debugAdminModule } from "./debug/debug.admin.module";
+import { sendNotificationRoute } from "./routes/notifications.route";
import { sessionAdminRoute } from "./routes/session.route";
import { usersAdminModule } from "./users/users.admin.module";
export const adminModule = buildModule({
pluginId: CONFIG_PLUGIN.pluginId,
name: "admin",
- routes: [sessionAdminRoute],
+ routes: [sessionAdminRoute, sendNotificationRoute],
modules: [usersAdminModule, debugAdminModule, advancedAdminModule],
cronJobs: [],
});
diff --git a/packages/vitnode/src/api/modules/admin/routes/notifications.route.ts b/packages/vitnode/src/api/modules/admin/routes/notifications.route.ts
new file mode 100644
index 000000000..f77856237
--- /dev/null
+++ b/packages/vitnode/src/api/modules/admin/routes/notifications.route.ts
@@ -0,0 +1,59 @@
+import { HTTPException } from "hono/http-exception";
+import { z } from "zod";
+
+import { buildRoute } from "@/api/lib/route";
+import { CONFIG_PLUGIN } from "@/config";
+import { notificationsChannel } from "@/ws/notifications";
+
+export const zodSendNotificationSchema = z.object({
+ description: z.string().optional(),
+ title: z.string().min(1, "Title is required"),
+ type: z.enum(["error", "info", "success", "warning"]).optional(),
+ userId: z.number(),
+});
+
+export const sendNotificationRoute = buildRoute({
+ pluginId: CONFIG_PLUGIN.pluginId,
+ route: {
+ method: "post",
+ description: "Send a notification to a user",
+ path: "/notifications/send",
+ request: {
+ body: {
+ content: {
+ "application/json": {
+ schema: zodSendNotificationSchema,
+ },
+ },
+ },
+ },
+ responses: {
+ 200: {
+ content: {
+ "application/json": {
+ schema: z.object({ success: z.boolean() }),
+ },
+ },
+ description: "Notification sent",
+ },
+ 403: {
+ description: "Access Denied",
+ },
+ },
+ },
+ handler: c => {
+ const admin = c.get("admin")?.user;
+ if (!admin) throw new HTTPException(403);
+
+ const { userId, title, description, type } = c.req.valid("json");
+
+ // Delivered only to that user's connections, across all their browsers.
+ c.get("realtime").sendToUser(userId, notificationsChannel, {
+ description,
+ title,
+ type,
+ });
+
+ return c.json({ success: true });
+ },
+});
diff --git a/packages/vitnode/src/views/admin/views/core/dashboard/dashboard-admin-view.tsx b/packages/vitnode/src/views/admin/views/core/dashboard/dashboard-admin-view.tsx
index 067fb3038..d9a296c2b 100644
--- a/packages/vitnode/src/views/admin/views/core/dashboard/dashboard-admin-view.tsx
+++ b/packages/vitnode/src/views/admin/views/core/dashboard/dashboard-admin-view.tsx
@@ -6,11 +6,13 @@ import { HeaderContent } from "@/components/ui/header-content";
import { getSessionAdminApi } from "@/lib/api/get-session-admin-api";
import { CONFIG } from "@/lib/config";
+import { SendNotificationAction } from "./send-notification/send-notification";
+
export const DashboardAdminView = async () => {
const session = await getSessionAdminApi();
const t = await getTranslations("admin.dashboard");
if (!session) return null;
- const { vitnode_version } = session;
+ const { user, vitnode_version } = session;
return (