@developer.krd/discord-dashboard 0.1.5 → 0.1.7

package/dist/index.cjs

@@ -46,7 +46,8 @@ var UserSchema = import_elysia.t.Object({
   username: import_elysia.t.String(),
   discriminator: import_elysia.t.String(),
   avatar: import_elysia.t.Nullable(import_elysia.t.String()),
-  global_name: import_elysia.t.Optional(import_elysia.t.Nullable(import_elysia.t.String()))
+  global_name: import_elysia.t.Optional(import_elysia.t.Nullable(import_elysia.t.String())),
+  avatarUrl: import_elysia.t.Optional(import_elysia.t.Nullable(import_elysia.t.String()))
 });
 var GuildSchema = import_elysia.t.Object({
   id: import_elysia.t.String(),
@@ -55,8 +56,8 @@ var GuildSchema = import_elysia.t.Object({
   owner: import_elysia.t.Boolean(),
   permissions: import_elysia.t.String(),
   iconUrl: import_elysia.t.Optional(import_elysia.t.Nullable(import_elysia.t.String())),
-  botInGuild: import_elysia.t.Optional(import_elysia.t.Nullable(import_elysia.t.Boolean())),
-  inviteUrl: import_elysia.t.Optional(import_elysia.t.Nullable(import_elysia.t.String()))
+  botInGuild: import_elysia.t.Optional(import_elysia.t.Boolean()),
+  inviteUrl: import_elysia.t.Optional(import_elysia.t.String())
 });
 var SessionSchema = import_elysia.t.Object({
   oauthState: import_elysia.t.Optional(import_elysia.t.String()),
@@ -2435,54 +2436,183 @@ function createElysiaAdapter(options) {
   const basePath = options.basePath ?? "/dashboard";
   const sessionName = options.sessionName ?? "discord_dashboard.sid";
   const app = options.app ?? new import_elysia2.Elysia({ adapter: (0, import_node.default)() });
+  const getSession = async (sessionSigner, cookie) => {
+    const cookieValue = cookie[sessionName]?.value;
+    if (!cookieValue) return null;
+    const session2 = await sessionSigner.verify(cookieValue);
+    return session2 ?? null;
+  };
+  const setSession = async (sessionSigner, cookie, session2) => {
+    const token = await sessionSigner.sign(session2);
+    cookie[sessionName].set({
+      value: token,
+      httpOnly: true,
+      sameSite: "lax",
+      path: "/"
+    });
+  };
+  const buildContext = (session2, query) => ({
+    user: session2.discordAuth.user,
+    guilds: (session2.discordAuth.guilds || []).map((guild) => ({
+      ...guild,
+      botInGuild: guild.botInGuild ?? void 0,
+      inviteUrl: guild.inviteUrl ?? void 0
+    })),
+    accessToken: session2.discordAuth.accessToken || "",
+    selectedGuildId: typeof query?.guildId === "string" ? query.guildId : void 0,
+    helpers: engine.helpers
+  });
   const router = new import_elysia2.Elysia({ prefix: basePath }).use(
     (0, import_jwt.default)({
       name: "sessionSigner",
       secret: options.sessionSecret,
       schema: SessionSchema
     })
-  ).derive(({ set }) => ({
-    html: (content) => {
-      set.headers["Content-Type"] = "text/html; charset=utf8";
-      return content;
-    }
-  })).get("/", async ({ sessionSigner, cookie, redirect, html }) => {
-    const cookieValue = cookie[sessionName].value;
-    if (!cookieValue) return redirect(`${basePath}/login`);
-    const sessionData = await sessionSigner.verify(cookieValue);
+  ).get("/", async ({ sessionSigner, cookie, redirect }) => {
+    const sessionData = await getSession(sessionSigner, cookie);
     if (!sessionData || !sessionData.discordAuth) return redirect(`${basePath}/login`);
-    return html(engine.render(basePath));
+    return new Response(engine.render(basePath), {
+      headers: {
+        "content-type": "text/html; charset=utf-8"
+      }
+    });
   }).get("/login", async ({ sessionSigner, cookie, redirect }) => {
     const state = (0, import_node_crypto2.randomBytes)(16).toString("hex");
-    const token = await sessionSigner.sign({ oauthState: state });
-    cookie[sessionName].set({
-      value: token,
-      httpOnly: true,
-      path: "/"
-    });
+    await setSession(sessionSigner, cookie, { oauthState: state });
     return redirect(engine.getAuthUrl(state));
   }).get("/callback", async ({ query, sessionSigner, cookie, redirect }) => {
     const { code, state } = query;
-    const cookieValue = cookie[sessionName].value;
-    if (!cookieValue) return redirect(`${basePath}/login`);
-    const session2 = await sessionSigner.verify(cookieValue);
-    if (!state || !session2 || state !== session2.oauthState) return redirect(`${basePath}/login`);
-    const tokens = await engine.exchangeCode(code);
-    const [user, guilds] = await Promise.all([engine.fetchUser(tokens.access_token), engine.fetchGuilds(tokens.access_token)]);
-    const token = await sessionSigner.sign({
-      oauthState: void 0,
-      discordAuth: {
-        accessToken: tokens.access_token,
-        user,
-        guilds
-      }
-    });
-    cookie[sessionName].set({
-      value: token,
-      httpOnly: true,
-      path: "/"
-    });
-    return redirect(basePath);
+    const session2 = await getSession(sessionSigner, cookie);
+    if (!code || !state || !session2 || state !== session2.oauthState) return redirect(`${basePath}/login`);
+    try {
+      const tokens = await engine.exchangeCode(code);
+      const [user, rawGuilds] = await Promise.all([engine.fetchUser(tokens.access_token), engine.fetchGuilds(tokens.access_token)]);
+      const ADMIN = 8n;
+      const MANAGE_GUILD = 32n;
+      const processedGuilds = rawGuilds.filter((guild) => {
+        const perms = BigInt(guild.permissions || "0");
+        return (perms & ADMIN) === ADMIN || (perms & MANAGE_GUILD) === MANAGE_GUILD;
+      }).map((guild) => ({
+        id: guild.id,
+        name: guild.name,
+        icon: guild.icon,
+        owner: guild.owner,
+        permissions: guild.permissions,
+        iconUrl: engine.helpers.getGuildIconUrl(guild.id, guild.icon),
+        botInGuild: options.client.guilds.cache.has(guild.id)
+      }));
+      await setSession(sessionSigner, cookie, {
+        discordAuth: {
+          accessToken: tokens.access_token,
+          user: {
+            id: user.id,
+            username: user.username,
+            discriminator: user.discriminator,
+            avatar: user.avatar,
+            global_name: user.global_name,
+            avatarUrl: engine.helpers.getUserAvatarUrl(user.id, user.avatar)
+          },
+          guilds: processedGuilds
+        }
+      });
+      return redirect(basePath);
+    } catch (error) {
+      console.error("Dashboard Auth Error:", error);
+      return redirect(`${basePath}/login`);
+    }
+  }).get("/api/session", async ({ sessionSigner, cookie }) => {
+    const session2 = await getSession(sessionSigner, cookie);
+    if (!session2?.discordAuth) return { authenticated: false };
+    return {
+      authenticated: true,
+      user: session2.discordAuth.user,
+      guildCount: session2.discordAuth.guilds.length
+    };
+  }).get("/api/guilds", async ({ sessionSigner, cookie, set }) => {
+    const session2 = await getSession(sessionSigner, cookie);
+    if (!session2?.discordAuth) {
+      set.status = 401;
+      return { error: "Unauthorized" };
+    }
+    return { guilds: session2.discordAuth.guilds };
+  }).get("/api/overview", async ({ sessionSigner, cookie, query, set }) => {
+    const session2 = await getSession(sessionSigner, cookie);
+    if (!session2?.discordAuth) {
+      set.status = 401;
+      return { error: "Unauthorized" };
+    }
+    const cards = options.getOverviewCards ? await options.getOverviewCards(buildContext(session2, query)) : [];
+    return { cards };
+  }).get("/api/home/categories", async ({ sessionSigner, cookie, query, set }) => {
+    const session2 = await getSession(sessionSigner, cookie);
+    if (!session2?.discordAuth) {
+      set.status = 401;
+      return { error: "Unauthorized" };
+    }
+    const categories = options.home?.getCategories ? await options.home.getCategories(buildContext(session2, query)) : [];
+    return { categories };
+  }).get("/api/home", async ({ sessionSigner, cookie, query, set }) => {
+    const session2 = await getSession(sessionSigner, cookie);
+    if (!session2?.discordAuth) {
+      set.status = 401;
+      return { error: "Unauthorized" };
+    }
+    const context = buildContext(session2, query);
+    const sections = options.home?.getSections ? await options.home.getSections(context) : [];
+    const categoryId = typeof query.categoryId === "string" ? query.categoryId : void 0;
+    const filteredSections = categoryId ? sections.filter((section) => section.categoryId === categoryId) : sections;
+    return { sections: filteredSections };
+  }).post("/api/home/:actionId", async ({ params, body, sessionSigner, cookie, query, set }) => {
+    const session2 = await getSession(sessionSigner, cookie);
+    if (!session2?.discordAuth) {
+      set.status = 401;
+      return { error: "Unauthorized" };
+    }
+    const actionFn = options.home?.actions?.[params.actionId];
+    if (!actionFn) {
+      set.status = 404;
+      return { error: "Action not found" };
+    }
+    try {
+      return await actionFn(buildContext(session2, query), body);
+    } catch (error) {
+      set.status = 500;
+      return { error: error instanceof Error ? error.message : "Action failed" };
+    }
+  }).get("/api/plugins", async ({ sessionSigner, cookie, query, set }) => {
+    const session2 = await getSession(sessionSigner, cookie);
+    if (!session2?.discordAuth) {
+      set.status = 401;
+      return { error: "Unauthorized" };
+    }
+    const context = buildContext(session2, query);
+    const resolvedPlugins = await Promise.all(
+      (options.plugins || []).map(async (plugin) => ({
+        id: plugin.id,
+        name: plugin.name,
+        description: plugin.description,
+        panels: plugin.getPanels ? await plugin.getPanels(context) : plugin.panels || []
+      }))
+    );
+    return { plugins: resolvedPlugins };
+  }).post("/api/plugins/:pluginId/:actionId", async ({ params, body, sessionSigner, cookie, query, set }) => {
+    const session2 = await getSession(sessionSigner, cookie);
+    if (!session2?.discordAuth) {
+      set.status = 401;
+      return { error: "Unauthorized" };
+    }
+    const plugin = options.plugins?.find((item) => item.id === params.pluginId);
+    if (!plugin || !plugin.actions?.[params.actionId]) {
+      set.status = 404;
+      return { error: "Plugin or action not found" };
+    }
+    try {
+      return await plugin.actions[params.actionId](buildContext(session2, query), body);
+    } catch (error) {
+      console.error(`Action Error (${params.pluginId}/${params.actionId}):`, error);
+      set.status = 500;
+      return { error: "Internal Server Error" };
+    }
   });
   app.use(router);
   return { app, engine };
@@ -2493,6 +2623,16 @@ var import_crypto = require("crypto");
 function createFastifyAdapter(fastify, options) {
   const engine = new DashboardEngine(options);
   const basePath = options.basePath ?? "/dashboard";
+  const buildContext = (request) => {
+    const query = request.query;
+    return {
+      user: request.session.discordAuth.user,
+      guilds: request.session.discordAuth.guilds || [],
+      accessToken: request.session.discordAuth.accessToken || "",
+      selectedGuildId: typeof query.guildId === "string" ? query.guildId : void 0,
+      helpers: engine.helpers
+    };
+  };
   fastify.register(
     async (instance) => {
       instance.get("/", async (request, reply) => {
@@ -2507,15 +2647,123 @@ function createFastifyAdapter(fastify, options) {
       instance.get("/callback", async (request, reply) => {
         const { code, state } = request.query;
         if (state !== request.session.oauthState) return reply.status(403).send("Invalid OAuth2 state");
-        const tokens = await engine.exchangeCode(code);
-        const [user, guilds] = await Promise.all([engine.fetchUser(tokens.access_token), engine.fetchGuilds(tokens.access_token)]);
-        request.session.discordAuth = {
-          accessToken: tokens.access_token,
-          user,
-          guilds
-        };
-        return reply.redirect(basePath);
+        try {
+          const tokens = await engine.exchangeCode(code);
+          const [user, rawGuilds] = await Promise.all([engine.fetchUser(tokens.access_token), engine.fetchGuilds(tokens.access_token)]);
+          const ADMIN = 8n;
+          const MANAGE_GUILD = 32n;
+          const processedGuilds = rawGuilds.filter((guild) => {
+            const perms = BigInt(guild.permissions || "0");
+            return (perms & ADMIN) === ADMIN || (perms & MANAGE_GUILD) === MANAGE_GUILD;
+          }).map((guild) => ({
+            ...guild,
+            iconUrl: engine.helpers.getGuildIconUrl(guild.id, guild.icon),
+            botInGuild: options.client.guilds.cache.has(guild.id)
+          }));
+          request.session.discordAuth = {
+            accessToken: tokens.access_token,
+            user: {
+              ...user,
+              avatarUrl: engine.helpers.getUserAvatarUrl(user.id, user.avatar)
+            },
+            guilds: processedGuilds
+          };
+          return reply.redirect(basePath);
+        } catch (error) {
+          console.error("Dashboard Auth Error:", error);
+          return reply.redirect(`${basePath}/login`);
+        }
+      });
+      instance.get("/api/session", async (request, reply) => {
+        if (!request.session.discordAuth) {
+          return reply.send({ authenticated: false });
+        }
+        return reply.send({
+          authenticated: true,
+          user: request.session.discordAuth.user,
+          guildCount: request.session.discordAuth.guilds.length
+        });
+      });
+      instance.get("/api/guilds", async (request, reply) => {
+        if (!request.session.discordAuth) {
+          return reply.status(401).send({ error: "Unauthorized" });
+        }
+        return reply.send({ guilds: request.session.discordAuth.guilds });
+      });
+      instance.get("/api/overview", async (request, reply) => {
+        if (!request.session.discordAuth) {
+          return reply.status(401).send({ error: "Unauthorized" });
+        }
+        const cards = options.getOverviewCards ? await options.getOverviewCards(buildContext(request)) : [];
+        return reply.send({ cards });
+      });
+      instance.get("/api/home/categories", async (request, reply) => {
+        if (!request.session.discordAuth) {
+          return reply.status(401).send({ error: "Unauthorized" });
+        }
+        const categories = options.home?.getCategories ? await options.home.getCategories(buildContext(request)) : [];
+        return reply.send({ categories });
+      });
+      instance.get("/api/home", async (request, reply) => {
+        if (!request.session.discordAuth) {
+          return reply.status(401).send({ error: "Unauthorized" });
+        }
+        const sections = options.home?.getSections ? await options.home.getSections(buildContext(request)) : [];
+        const query = request.query;
+        const categoryId = typeof query.categoryId === "string" ? query.categoryId : void 0;
+        const filteredSections = categoryId ? sections.filter((section) => section.categoryId === categoryId) : sections;
+        return reply.send({ sections: filteredSections });
+      });
+      instance.post("/api/home/:actionId", async (request, reply) => {
+        if (!request.session.discordAuth) {
+          return reply.status(401).send({ error: "Unauthorized" });
+        }
+        const actionFn = options.home?.actions?.[request.params.actionId];
+        if (!actionFn) {
+          return reply.status(404).send({ error: "Action not found" });
+        }
+        try {
+          const result = await actionFn(buildContext(request), request.body);
+          return reply.send(result);
+        } catch (error) {
+          return reply.status(500).send({ error: error instanceof Error ? error.message : "Action failed" });
+        }
+      });
+      instance.get("/api/plugins", async (request, reply) => {
+        if (!request.session.discordAuth) {
+          return reply.status(401).send({ error: "Unauthorized" });
+        }
+        const context = buildContext(request);
+        const resolvedPlugins = await Promise.all(
+          (options.plugins || []).map(async (plugin) => ({
+            id: plugin.id,
+            name: plugin.name,
+            description: plugin.description,
+            panels: plugin.getPanels ? await plugin.getPanels(context) : plugin.panels || []
+          }))
+        );
+        return reply.send({ plugins: resolvedPlugins });
       });
+      instance.post(
+        "/api/plugins/:pluginId/:actionId",
+        async (request, reply) => {
+          if (!request.session.discordAuth) {
+            return reply.status(401).send({ error: "Unauthorized" });
+          }
+          const { pluginId, actionId } = request.params;
+          const plugin = options.plugins?.find((item) => item.id === pluginId);
+          if (!plugin || !plugin.actions?.[actionId]) {
+            return reply.status(404).send({ error: "Plugin or action not found" });
+          }
+          try {
+            const result = await plugin.actions[actionId](buildContext(request), request.body);
+            return reply.send(result);
+          } catch (error) {
+            console.error(`Action Error (${pluginId}/${actionId}):`, error);
+            return reply.status(500).send({ error: "Internal Server Error" });
+          }
+        }
+      );
     },
     { prefix: basePath }
   );