Upload 43 files

Dockerfile

@@ -0,0 +1,23 @@
+# Use a lightweight Node.js image
+FROM node:20-slim
+
+# Create app directory
+WORKDIR /usr/src/app
+
+# Copy package files first to optimize Docker layer caching
+COPY package*.json ./
+
+# Install dependencies
+RUN npm install
+
+# Copy all the remaining project files
+COPY . .
+
+# Define the port Hugging Face Spaces expects apps to run on
+EXPOSE 7860
+
+# Force the bot's keep-alive web server to run on port 7860
+ENV PORT=7860
+
+# Command to start the bot
+CMD [ "npm", "start" ]

package-lock.json

@@ -0,0 +1,657 @@
+{
+  "name": "wsb-bot",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "wsb-bot",
+      "version": "1.0.0",
+      "dependencies": {
+        "@octokit/rest": "^22.0.1",
+        "@supabase/supabase-js": "^2.99.3",
+        "discord.js": "^14.16.0",
+        "dotenv": "^16.4.0",
+        "node-fetch": "^2.7.0"
+      }
+    },
+    "node_modules/@discordjs/builders": {
+      "version": "1.13.1",
+      "resolved": "https://registry.npmjs.org/@discordjs/builders/-/builders-1.13.1.tgz",
+      "integrity": "sha512-cOU0UDHc3lp/5nKByDxkmRiNZBpdp0kx55aarbiAfakfKJHlxv/yFW1zmIqCAmwH5CRlrH9iMFKJMpvW4DPB+w==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@discordjs/formatters": "^0.6.2",
+        "@discordjs/util": "^1.2.0",
+        "@sapphire/shapeshift": "^4.0.0",
+        "discord-api-types": "^0.38.33",
+        "fast-deep-equal": "^3.1.3",
+        "ts-mixer": "^6.0.4",
+        "tslib": "^2.6.3"
+      },
+      "engines": {
+        "node": ">=16.11.0"
+      },
+      "funding": {
+        "url": "https://github.com/discordjs/discord.js?sponsor"
+      }
+    },
+    "node_modules/@discordjs/collection": {
+      "version": "1.5.3",
+      "resolved": "https://registry.npmjs.org/@discordjs/collection/-/collection-1.5.3.tgz",
+      "integrity": "sha512-SVb428OMd3WO1paV3rm6tSjM4wC+Kecaa1EUGX7vc6/fddvw/6lg90z4QtCqm21zvVe92vMMDt9+DkIvjXImQQ==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=16.11.0"
+      }
+    },
+    "node_modules/@discordjs/formatters": {
+      "version": "0.6.2",
+      "resolved": "https://registry.npmjs.org/@discordjs/formatters/-/formatters-0.6.2.tgz",
+      "integrity": "sha512-y4UPwWhH6vChKRkGdMB4odasUbHOUwy7KL+OVwF86PvT6QVOwElx+TiI1/6kcmcEe+g5YRXJFiXSXUdabqZOvQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "discord-api-types": "^0.38.33"
+      },
+      "engines": {
+        "node": ">=16.11.0"
+      },
+      "funding": {
+        "url": "https://github.com/discordjs/discord.js?sponsor"
+      }
+    },
+    "node_modules/@discordjs/rest": {
+      "version": "2.6.0",
+      "resolved": "https://registry.npmjs.org/@discordjs/rest/-/rest-2.6.0.tgz",
+      "integrity": "sha512-RDYrhmpB7mTvmCKcpj+pc5k7POKszS4E2O9TYc+U+Y4iaCP+r910QdO43qmpOja8LRr1RJ0b3U+CqVsnPqzf4w==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@discordjs/collection": "^2.1.1",
+        "@discordjs/util": "^1.1.1",
+        "@sapphire/async-queue": "^1.5.3",
+        "@sapphire/snowflake": "^3.5.3",
+        "@vladfrangu/async_event_emitter": "^2.4.6",
+        "discord-api-types": "^0.38.16",
+        "magic-bytes.js": "^1.10.0",
+        "tslib": "^2.6.3",
+        "undici": "6.21.3"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/discordjs/discord.js?sponsor"
+      }
+    },
+    "node_modules/@discordjs/rest/node_modules/@discordjs/collection": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/@discordjs/collection/-/collection-2.1.1.tgz",
+      "integrity": "sha512-LiSusze9Tc7qF03sLCujF5iZp7K+vRNEDBZ86FT9aQAv3vxMLihUvKvpsCWiQ2DJq1tVckopKm1rxomgNUc9hg==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/discordjs/discord.js?sponsor"
+      }
+    },
+    "node_modules/@discordjs/util": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/@discordjs/util/-/util-1.2.0.tgz",
+      "integrity": "sha512-3LKP7F2+atl9vJFhaBjn4nOaSWahZ/yWjOvA4e5pnXkt2qyXRCHLxoBQy81GFtLGCq7K9lPm9R517M1U+/90Qg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "discord-api-types": "^0.38.33"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/discordjs/discord.js?sponsor"
+      }
+    },
+    "node_modules/@discordjs/ws": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@discordjs/ws/-/ws-1.2.3.tgz",
+      "integrity": "sha512-wPlQDxEmlDg5IxhJPuxXr3Vy9AjYq5xCvFWGJyD7w7Np8ZGu+Mc+97LCoEc/+AYCo2IDpKioiH0/c/mj5ZR9Uw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@discordjs/collection": "^2.1.0",
+        "@discordjs/rest": "^2.5.1",
+        "@discordjs/util": "^1.1.0",
+        "@sapphire/async-queue": "^1.5.2",
+        "@types/ws": "^8.5.10",
+        "@vladfrangu/async_event_emitter": "^2.2.4",
+        "discord-api-types": "^0.38.1",
+        "tslib": "^2.6.2",
+        "ws": "^8.17.0"
+      },
+      "engines": {
+        "node": ">=16.11.0"
+      },
+      "funding": {
+        "url": "https://github.com/discordjs/discord.js?sponsor"
+      }
+    },
+    "node_modules/@discordjs/ws/node_modules/@discordjs/collection": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/@discordjs/collection/-/collection-2.1.1.tgz",
+      "integrity": "sha512-LiSusze9Tc7qF03sLCujF5iZp7K+vRNEDBZ86FT9aQAv3vxMLihUvKvpsCWiQ2DJq1tVckopKm1rxomgNUc9hg==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/discordjs/discord.js?sponsor"
+      }
+    },
+    "node_modules/@octokit/auth-token": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-6.0.0.tgz",
+      "integrity": "sha512-P4YJBPdPSpWTQ1NU4XYdvHvXJJDxM6YwpS0FZHRgP7YFkdVxsWcpWGy/NVqlAA7PcPCnMacXlRm1y2PFZRWL/w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@octokit/core": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/@octokit/core/-/core-7.0.6.tgz",
+      "integrity": "sha512-DhGl4xMVFGVIyMwswXeyzdL4uXD5OGILGX5N8Y+f6W7LhC1Ze2poSNrkF/fedpVDHEEZ+PHFW0vL14I+mm8K3Q==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@octokit/auth-token": "^6.0.0",
+        "@octokit/graphql": "^9.0.3",
+        "@octokit/request": "^10.0.6",
+        "@octokit/request-error": "^7.0.2",
+        "@octokit/types": "^16.0.0",
+        "before-after-hook": "^4.0.0",
+        "universal-user-agent": "^7.0.0"
+      },
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@octokit/endpoint": {
+      "version": "11.0.3",
+      "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-11.0.3.tgz",
+      "integrity": "sha512-FWFlNxghg4HrXkD3ifYbS/IdL/mDHjh9QcsNyhQjN8dplUoZbejsdpmuqdA76nxj2xoWPs7p8uX2SNr9rYu0Ag==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/types": "^16.0.0",
+        "universal-user-agent": "^7.0.2"
+      },
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@octokit/graphql": {
+      "version": "9.0.3",
+      "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-9.0.3.tgz",
+      "integrity": "sha512-grAEuupr/C1rALFnXTv6ZQhFuL1D8G5y8CN04RgrO4FIPMrtm+mcZzFG7dcBm+nq+1ppNixu+Jd78aeJOYxlGA==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/request": "^10.0.6",
+        "@octokit/types": "^16.0.0",
+        "universal-user-agent": "^7.0.0"
+      },
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@octokit/openapi-types": {
+      "version": "27.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-27.0.0.tgz",
+      "integrity": "sha512-whrdktVs1h6gtR+09+QsNk2+FO+49j6ga1c55YZudfEG+oKJVvJLQi3zkOm5JjiUXAagWK2tI2kTGKJ2Ys7MGA==",
+      "license": "MIT"
+    },
+    "node_modules/@octokit/plugin-paginate-rest": {
+      "version": "14.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-14.0.0.tgz",
+      "integrity": "sha512-fNVRE7ufJiAA3XUrha2omTA39M6IXIc6GIZLvlbsm8QOQCYvpq/LkMNGyFlB1d8hTDzsAXa3OKtybdMAYsV/fw==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/types": "^16.0.0"
+      },
+      "engines": {
+        "node": ">= 20"
+      },
+      "peerDependencies": {
+        "@octokit/core": ">=6"
+      }
+    },
+    "node_modules/@octokit/plugin-request-log": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-request-log/-/plugin-request-log-6.0.0.tgz",
+      "integrity": "sha512-UkOzeEN3W91/eBq9sPZNQ7sUBvYCqYbrrD8gTbBuGtHEuycE4/awMXcYvx6sVYo7LypPhmQwwpUe4Yyu4QZN5Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 20"
+      },
+      "peerDependencies": {
+        "@octokit/core": ">=6"
+      }
+    },
+    "node_modules/@octokit/plugin-rest-endpoint-methods": {
+      "version": "17.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-17.0.0.tgz",
+      "integrity": "sha512-B5yCyIlOJFPqUUeiD0cnBJwWJO8lkJs5d8+ze9QDP6SvfiXSz1BF+91+0MeI1d2yxgOhU/O+CvtiZ9jSkHhFAw==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/types": "^16.0.0"
+      },
+      "engines": {
+        "node": ">= 20"
+      },
+      "peerDependencies": {
+        "@octokit/core": ">=6"
+      }
+    },
+    "node_modules/@octokit/request": {
+      "version": "10.0.8",
+      "resolved": "https://registry.npmjs.org/@octokit/request/-/request-10.0.8.tgz",
+      "integrity": "sha512-SJZNwY9pur9Agf7l87ywFi14W+Hd9Jg6Ifivsd33+/bGUQIjNujdFiXII2/qSlN2ybqUHfp5xpekMEjIBTjlSw==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/endpoint": "^11.0.3",
+        "@octokit/request-error": "^7.0.2",
+        "@octokit/types": "^16.0.0",
+        "fast-content-type-parse": "^3.0.0",
+        "json-with-bigint": "^3.5.3",
+        "universal-user-agent": "^7.0.2"
+      },
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@octokit/request-error": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-7.1.0.tgz",
+      "integrity": "sha512-KMQIfq5sOPpkQYajXHwnhjCC0slzCNScLHs9JafXc4RAJI+9f+jNDlBNaIMTvazOPLgb4BnlhGJOTbnN0wIjPw==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/types": "^16.0.0"
+      },
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@octokit/rest": {
+      "version": "22.0.1",
+      "resolved": "https://registry.npmjs.org/@octokit/rest/-/rest-22.0.1.tgz",
+      "integrity": "sha512-Jzbhzl3CEexhnivb1iQ0KJ7s5vvjMWcmRtq5aUsKmKDrRW6z3r84ngmiFKFvpZjpiU/9/S6ITPFRpn5s/3uQJw==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/core": "^7.0.6",
+        "@octokit/plugin-paginate-rest": "^14.0.0",
+        "@octokit/plugin-request-log": "^6.0.0",
+        "@octokit/plugin-rest-endpoint-methods": "^17.0.0"
+      },
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@octokit/types": {
+      "version": "16.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/types/-/types-16.0.0.tgz",
+      "integrity": "sha512-sKq+9r1Mm4efXW1FCk7hFSeJo4QKreL/tTbR0rz/qx/r1Oa2VV83LTA/H/MuCOX7uCIJmQVRKBcbmWoySjAnSg==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/openapi-types": "^27.0.0"
+      }
+    },
+    "node_modules/@sapphire/async-queue": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@sapphire/async-queue/-/async-queue-1.5.5.tgz",
+      "integrity": "sha512-cvGzxbba6sav2zZkH8GPf2oGk9yYoD5qrNWdu9fRehifgnFZJMV+nuy2nON2roRO4yQQ+v7MK/Pktl/HgfsUXg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=v14.0.0",
+        "npm": ">=7.0.0"
+      }
+    },
+    "node_modules/@sapphire/shapeshift": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/@sapphire/shapeshift/-/shapeshift-4.0.0.tgz",
+      "integrity": "sha512-d9dUmWVA7MMiKobL3VpLF8P2aeanRTu6ypG2OIaEv/ZHH/SUQ2iHOVyi5wAPjQ+HmnMuL0whK9ez8I/raWbtIg==",
+      "license": "MIT",
+      "dependencies": {
+        "fast-deep-equal": "^3.1.3",
+        "lodash": "^4.17.21"
+      },
+      "engines": {
+        "node": ">=v16"
+      }
+    },
+    "node_modules/@sapphire/snowflake": {
+      "version": "3.5.3",
+      "resolved": "https://registry.npmjs.org/@sapphire/snowflake/-/snowflake-3.5.3.tgz",
+      "integrity": "sha512-jjmJywLAFoWeBi1W7994zZyiNWPIiqRRNAmSERxyg93xRGzNYvGjlZ0gR6x0F4gPRi2+0O6S71kOZYyr3cxaIQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=v14.0.0",
+        "npm": ">=7.0.0"
+      }
+    },
+    "node_modules/@supabase/auth-js": {
+      "version": "2.99.3",
+      "resolved": "https://registry.npmjs.org/@supabase/auth-js/-/auth-js-2.99.3.tgz",
+      "integrity": "sha512-vMEVLA1kGGYd/kdsJSwtjiFUZM1nGfrz2DWmgMBZtocV48qL+L2+4QpIkueXyBEumMQZFEyhz57i/5zGHjvdBw==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "2.8.1"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@supabase/functions-js": {
+      "version": "2.99.3",
+      "resolved": "https://registry.npmjs.org/@supabase/functions-js/-/functions-js-2.99.3.tgz",
+      "integrity": "sha512-6tk2zrcBkzKaaBXPOG5nshn30uJNFGOH9LxOnE8i850eQmsX+jVm7vql9kTPyvUzEHwU4zdjSOkXS9M+9ukMVA==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "2.8.1"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@supabase/postgrest-js": {
+      "version": "2.99.3",
+      "resolved": "https://registry.npmjs.org/@supabase/postgrest-js/-/postgrest-js-2.99.3.tgz",
+      "integrity": "sha512-8HxEf+zNycj7Z8+ONhhlu+7J7Ha+L6weyCtdEeK2mN5OWJbh6n4LPU4iuJ5UlCvvNnbSXMoutY7piITEEAgl2g==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "2.8.1"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@supabase/realtime-js": {
+      "version": "2.99.3",
+      "resolved": "https://registry.npmjs.org/@supabase/realtime-js/-/realtime-js-2.99.3.tgz",
+      "integrity": "sha512-c1azgZ2nZPczbY5k5u5iFrk1InpxN81IvNE+UBAkjrBz3yc5ALLJNkeTQwbJZT4PZBuYXEzqYGLMuh9fdTtTMg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/phoenix": "^1.6.6",
+        "@types/ws": "^8.18.1",
+        "tslib": "2.8.1",
+        "ws": "^8.18.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@supabase/storage-js": {
+      "version": "2.99.3",
+      "resolved": "https://registry.npmjs.org/@supabase/storage-js/-/storage-js-2.99.3.tgz",
+      "integrity": "sha512-lOfIm4hInNcd8x0i1LWphnLKxec42wwbjs+vhaVAvR801Vda0UAMbTooUY6gfqgQb8v29GofqKuQMMTAsl6w/w==",
+      "license": "MIT",
+      "dependencies": {
+        "iceberg-js": "^0.8.1",
+        "tslib": "2.8.1"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@supabase/supabase-js": {
+      "version": "2.99.3",
+      "resolved": "https://registry.npmjs.org/@supabase/supabase-js/-/supabase-js-2.99.3.tgz",
+      "integrity": "sha512-GuPbzoEaI51AkLw9VGhLNvnzw4PHbS3p8j2/JlvLeZNQMKwZw4aEYQIDBRtFwL5Nv7/275n9m4DHtakY8nCvgg==",
+      "license": "MIT",
+      "dependencies": {
+        "@supabase/auth-js": "2.99.3",
+        "@supabase/functions-js": "2.99.3",
+        "@supabase/postgrest-js": "2.99.3",
+        "@supabase/realtime-js": "2.99.3",
+        "@supabase/storage-js": "2.99.3"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "25.3.3",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-25.3.3.tgz",
+      "integrity": "sha512-DpzbrH7wIcBaJibpKo9nnSQL0MTRdnWttGyE5haGwK86xgMOkFLp7vEyfQPGLOJh5wNYiJ3V9PmUMDhV9u8kkQ==",
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~7.18.0"
+      }
+    },
+    "node_modules/@types/phoenix": {
+      "version": "1.6.7",
+      "resolved": "https://registry.npmjs.org/@types/phoenix/-/phoenix-1.6.7.tgz",
+      "integrity": "sha512-oN9ive//QSBkf19rfDv45M7eZPi0eEXylht2OLEXicu5b4KoQ1OzXIw+xDSGWxSxe1JmepRR/ZH283vsu518/Q==",
+      "license": "MIT"
+    },
+    "node_modules/@types/ws": {
+      "version": "8.18.1",
+      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.1.tgz",
+      "integrity": "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@vladfrangu/async_event_emitter": {
+      "version": "2.4.7",
+      "resolved": "https://registry.npmjs.org/@vladfrangu/async_event_emitter/-/async_event_emitter-2.4.7.tgz",
+      "integrity": "sha512-Xfe6rpCTxSxfbswi/W/Pz7zp1WWSNn4A0eW4mLkQUewCrXXtMj31lCg+iQyTkh/CkusZSq9eDflu7tjEDXUY6g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=v14.0.0",
+        "npm": ">=7.0.0"
+      }
+    },
+    "node_modules/before-after-hook": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/before-after-hook/-/before-after-hook-4.0.0.tgz",
+      "integrity": "sha512-q6tR3RPqIB1pMiTRMFcZwuG5T8vwp+vUvEG0vuI6B+Rikh5BfPp2fQ82c925FOs+b0lcFQ8CFrL+KbilfZFhOQ==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/discord-api-types": {
+      "version": "0.38.40",
+      "resolved": "https://registry.npmjs.org/discord-api-types/-/discord-api-types-0.38.40.tgz",
+      "integrity": "sha512-P/His8cotqZgQqrt+hzrocp9L8RhQQz1GkrCnC9TMJ8Uw2q0tg8YyqJyGULxhXn/8kxHETN4IppmOv+P2m82lQ==",
+      "license": "MIT",
+      "workspaces": [
+        "scripts/actions/documentation"
+      ]
+    },
+    "node_modules/discord.js": {
+      "version": "14.25.1",
+      "resolved": "https://registry.npmjs.org/discord.js/-/discord.js-14.25.1.tgz",
+      "integrity": "sha512-2l0gsPOLPs5t6GFZfQZKnL1OJNYFcuC/ETWsW4VtKVD/tg4ICa9x+jb9bkPffkMdRpRpuUaO/fKkHCBeiCKh8g==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@discordjs/builders": "^1.13.0",
+        "@discordjs/collection": "1.5.3",
+        "@discordjs/formatters": "^0.6.2",
+        "@discordjs/rest": "^2.6.0",
+        "@discordjs/util": "^1.2.0",
+        "@discordjs/ws": "^1.2.3",
+        "@sapphire/snowflake": "3.5.3",
+        "discord-api-types": "^0.38.33",
+        "fast-deep-equal": "3.1.3",
+        "lodash.snakecase": "4.1.1",
+        "magic-bytes.js": "^1.10.0",
+        "tslib": "^2.6.3",
+        "undici": "6.21.3"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/discordjs/discord.js?sponsor"
+      }
+    },
+    "node_modules/dotenv": {
+      "version": "16.6.1",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.6.1.tgz",
+      "integrity": "sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://dotenvx.com"
+      }
+    },
+    "node_modules/fast-content-type-parse": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/fast-content-type-parse/-/fast-content-type-parse-3.0.0.tgz",
+      "integrity": "sha512-ZvLdcY8P+N8mGQJahJV5G4U88CSvT1rP8ApL6uETe88MBXrBHAkZlSEySdUlyztF7ccb+Znos3TFqaepHxdhBg==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fastify"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fastify"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+      "license": "MIT"
+    },
+    "node_modules/iceberg-js": {
+      "version": "0.8.1",
+      "resolved": "https://registry.npmjs.org/iceberg-js/-/iceberg-js-0.8.1.tgz",
+      "integrity": "sha512-1dhVQZXhcHje7798IVM+xoo/1ZdVfzOMIc8/rgVSijRK38EDqOJoGula9N/8ZI5RD8QTxNQtK/Gozpr+qUqRRA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/json-with-bigint": {
+      "version": "3.5.7",
+      "resolved": "https://registry.npmjs.org/json-with-bigint/-/json-with-bigint-3.5.7.tgz",
+      "integrity": "sha512-7ei3MdAI5+fJPVnKlW77TKNKwQ5ppSzWvhPuSuINT/GYW9ZOC1eRKOuhV9yHG5aEsUPj9BBx5JIekkmoLHxZOw==",
+      "license": "MIT"
+    },
+    "node_modules/lodash": {
+      "version": "4.17.23",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.23.tgz",
+      "integrity": "sha512-LgVTMpQtIopCi79SJeDiP0TfWi5CNEc/L/aRdTh3yIvmZXTnheWpKjSZhnvMl8iXbC1tFg9gdHHDMLoV7CnG+w==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.snakecase": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/lodash.snakecase/-/lodash.snakecase-4.1.1.tgz",
+      "integrity": "sha512-QZ1d4xoBHYUeuouhEq3lk3Uq7ldgyFXGBhg04+oRLnIz8o9T65Eh+8YdroUwn846zchkA9yDsDl5CVVaV2nqYw==",
+      "license": "MIT"
+    },
+    "node_modules/magic-bytes.js": {
+      "version": "1.13.0",
+      "resolved": "https://registry.npmjs.org/magic-bytes.js/-/magic-bytes.js-1.13.0.tgz",
+      "integrity": "sha512-afO2mnxW7GDTXMm5/AoN1WuOcdoKhtgXjIvHmobqTD1grNplhGdv3PFOyjCVmrnOZBIT/gD/koDKpYG+0mvHcg==",
+      "license": "MIT"
+    },
+    "node_modules/node-fetch": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
+      "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==",
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-url": "^5.0.0"
+      },
+      "engines": {
+        "node": "4.x || >=6.0.0"
+      },
+      "peerDependencies": {
+        "encoding": "^0.1.0"
+      },
+      "peerDependenciesMeta": {
+        "encoding": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/tr46": {
+      "version": "0.0.3",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
+      "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==",
+      "license": "MIT"
+    },
+    "node_modules/ts-mixer": {
+      "version": "6.0.4",
+      "resolved": "https://registry.npmjs.org/ts-mixer/-/ts-mixer-6.0.4.tgz",
+      "integrity": "sha512-ufKpbmrugz5Aou4wcr5Wc1UUFWOLhq+Fm6qa6P0w0K5Qw2yhaUoiWszhCVuNQyNwrlGiscHOmqYoAox1PtvgjA==",
+      "license": "MIT"
+    },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "license": "0BSD"
+    },
+    "node_modules/undici": {
+      "version": "6.21.3",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-6.21.3.tgz",
+      "integrity": "sha512-gBLkYIlEnSp8pFbT64yFgGE6UIB9tAkhukC23PmMDCe5Nd+cRqKxSjw5y54MK2AZMgZfJWMaNE4nYUHgi1XEOw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "7.18.2",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.18.2.tgz",
+      "integrity": "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==",
+      "license": "MIT"
+    },
+    "node_modules/universal-user-agent": {
+      "version": "7.0.3",
+      "resolved": "https://registry.npmjs.org/universal-user-agent/-/universal-user-agent-7.0.3.tgz",
+      "integrity": "sha512-TmnEAEAsBJVZM/AADELsK76llnwcf9vMKuPz8JflO1frO8Lchitr0fNaN9d+Ap0BjKtqWqd/J17qeDnXh8CL2A==",
+      "license": "ISC"
+    },
+    "node_modules/webidl-conversions": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
+      "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==",
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/whatwg-url": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
+      "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
+      "license": "MIT",
+      "dependencies": {
+        "tr46": "~0.0.3",
+        "webidl-conversions": "^3.0.0"
+      }
+    },
+    "node_modules/ws": {
+      "version": "8.19.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz",
+      "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    }
+  }
+}

package.json

@@ -0,0 +1,16 @@
+{
+  "name": "wsb-bot",
+  "version": "1.0.0",
+  "description": "WSB — Wyvern Softworks Bot",
+  "main": "src/index.js",
+  "scripts": {
+    "start": "node src/index.js"
+  },
+  "dependencies": {
+    "@octokit/rest": "^22.0.1",
+    "@supabase/supabase-js": "^2.99.3",
+    "discord.js": "^14.16.0",
+    "dotenv": "^16.4.0",
+    "node-fetch": "^2.7.0"
+  }
+}

src/commands/applyUpdates.js

@@ -0,0 +1,131 @@
+const { PermissionFlagsBits, ChannelType } = require('discord.js');
+const { stmts } = require('../database');
+const { successEmbed, errorEmbed } = require('../utils/embeds');
+const { Colors, Roles } = require('../config');
+
+module.exports = {
+    async execute(client, message) {
+        const guild = await client.guilds.fetch(process.env.GUILD_ID);
+        await guild.roles.fetch();
+        await guild.channels.fetch();
+
+        const log = [];
+
+        // ── 1. Create missing roles ──────────────────────────────
+        const newRoles = ['@@ Server Manager', '@@ Moderator'];
+        for (const roleName of newRoles) {
+            const existing = guild.roles.cache.find(r => r.name === roleName);
+            if (existing) {
+                log.push(`⏭️ Role **${roleName}** already exists`);
+                continue;
+            }
+            const def = Roles.find(r => r.name === roleName);
+            if (!def) continue;
+
+            // Find position: place below Co-Owner, above Staff
+            const staffRole = guild.roles.cache.find(r => r.name === '@@ Staff');
+            const pos = staffRole ? staffRole.position + 1 : 1;
+
+            await guild.roles.create({
+                name: def.name,
+                color: def.color,
+                permissions: def.permissions,
+                hoist: def.hoist,
+                mentionable: def.mentionable,
+                position: pos,
+            });
+            log.push(`✅ Created role **${roleName}**`);
+        }
+
+        // ── 2. Create owner-chat in STAFF ONLY category ──────────
+        const staffCategory = guild.channels.cache.find(
+            c => c.type === ChannelType.GuildCategory && c.name.includes('STAFF ONLY')
+        );
+        const ownerChatExists = guild.channels.cache.find(c => c.name === '👑・owner-chat');
+
+        if (ownerChatExists) {
+            log.push(`⏭️ Channel **👑・owner-chat** already exists`);
+        } else if (!staffCategory) {
+            log.push(`⚠️ STAFF ONLY category not found — skipped owner-chat`);
+        } else {
+            // Fetch roles for permissions
+            const everyoneRole = guild.roles.everyone;
+            const ownerRole = guild.roles.cache.find(r => r.name === '@@ Owner');
+            const coOwnerRole = guild.roles.cache.find(r => r.name === '@@ Co-Owner');
+            const svrMgrRole = guild.roles.cache.find(r => r.name === '@@ Server Manager');
+
+            const overwrites = [
+                { id: everyoneRole.id, deny: [PermissionFlagsBits.ViewChannel] },
+            ];
+            if (ownerRole) overwrites.push({ id: ownerRole.id, allow: [PermissionFlagsBits.ViewChannel, PermissionFlagsBits.SendMessages] });
+            if (coOwnerRole) overwrites.push({ id: coOwnerRole.id, allow: [PermissionFlagsBits.ViewChannel, PermissionFlagsBits.SendMessages] });
+            if (svrMgrRole) overwrites.push({ id: svrMgrRole.id, allow: [PermissionFlagsBits.ViewChannel, PermissionFlagsBits.SendMessages] });
+
+            // Get staff-chat to position owner-chat above it
+            const staffChat = guild.channels.cache.find(c => c.name === '🛡️・staff-chat');
+
+            const ownerChat = await guild.channels.create({
+                name: '👑・owner-chat',
+                type: ChannelType.GuildText,
+                parent: staffCategory.id,
+                permissionOverwrites: overwrites,
+            });
+
+            // Move above staff-chat
+            if (staffChat) {
+                await ownerChat.setPosition(staffChat.position);
+            }
+
+            stmts.setState.run('channel_👑・owner-chat', ownerChat.id);
+            log.push(`✅ Created **👑・owner-chat** (above staff-chat)`);
+        }
+
+        // ── 3. Lock Resources channels to owner-only send ────────
+        const resourceChannels = ['🌐・resources', '🌐・free-assets', '🌐・scripts', '🌐・drivers'];
+        const everyoneRole = guild.roles.everyone;
+        const ownerRole = guild.roles.cache.find(r => r.name === '@@ Owner');
+        const verifiedRole = guild.roles.cache.find(r => r.name === '@@ Verified');
+        const staffRole = guild.roles.cache.find(r => r.name === '@@ Staff');
+        const boosterRole = guild.roles.cache.find(r => r.name === '@@ Booster');
+
+        for (const chName of resourceChannels) {
+            const ch = guild.channels.cache.find(c => c.name === chName);
+            if (!ch) {
+                log.push(`⚠️ Channel **${chName}** not found — skipped`);
+                continue;
+            }
+
+            const overwrites = [
+                { id: everyoneRole.id, deny: [PermissionFlagsBits.ViewChannel, PermissionFlagsBits.SendMessages] },
+            ];
+            if (verifiedRole) overwrites.push({ id: verifiedRole.id, allow: [PermissionFlagsBits.ViewChannel], deny: [PermissionFlagsBits.SendMessages, PermissionFlagsBits.AttachFiles] });
+            if (boosterRole) overwrites.push({ id: boosterRole.id, allow: [PermissionFlagsBits.ViewChannel], deny: [PermissionFlagsBits.SendMessages, PermissionFlagsBits.AttachFiles] });
+            if (staffRole) overwrites.push({ id: staffRole.id, allow: [PermissionFlagsBits.ViewChannel], deny: [PermissionFlagsBits.SendMessages, PermissionFlagsBits.AttachFiles] });
+            if (ownerRole) overwrites.push({ id: ownerRole.id, allow: [PermissionFlagsBits.ViewChannel, PermissionFlagsBits.SendMessages, PermissionFlagsBits.AttachFiles] });
+
+            await ch.permissionOverwrites.set(overwrites);
+            log.push(`🔒 Locked **${chName}** — owner-only send`);
+        }
+
+        // ── 4. Lock booster-rewards to owner-only send ───────────
+        const boosterRewards = guild.channels.cache.find(c => c.name === '💎・booster-rewards');
+        if (boosterRewards) {
+            const overwrites = [
+                { id: everyoneRole.id, deny: [PermissionFlagsBits.ViewChannel, PermissionFlagsBits.SendMessages] },
+            ];
+            if (boosterRole) overwrites.push({ id: boosterRole.id, allow: [PermissionFlagsBits.ViewChannel], deny: [PermissionFlagsBits.SendMessages, PermissionFlagsBits.AttachFiles] });
+            if (staffRole) overwrites.push({ id: staffRole.id, allow: [PermissionFlagsBits.ViewChannel], deny: [PermissionFlagsBits.SendMessages, PermissionFlagsBits.AttachFiles] });
+            if (ownerRole) overwrites.push({ id: ownerRole.id, allow: [PermissionFlagsBits.ViewChannel, PermissionFlagsBits.SendMessages, PermissionFlagsBits.AttachFiles] });
+
+            await boosterRewards.permissionOverwrites.set(overwrites);
+            log.push(`🔒 Locked **💎・booster-rewards** — owner-only send`);
+        } else {
+            log.push(`⚠️ Channel **💎・booster-rewards** not found — skipped`);
+        }
+
+        // ── Done ─────────────────────────────────────────────────
+        await message.reply({
+            embeds: [successEmbed('✅ Updates Applied', log.join('\n'))],
+        });
+    },
+};

src/commands/backupLayout.js

@@ -0,0 +1,67 @@
+const { createEmbed } = require('../utils/embeds');
+const { Colors } = require('../config');
+
+module.exports = {
+    name: 'backup layout',
+    async execute(client, message) {
+        const guildId = process.env.GUILD_ID;
+        const guild = await client.guilds.fetch(guildId);
+
+        // Fetch all channels and roles
+        await guild.channels.fetch();
+        await guild.roles.fetch();
+
+        const backup = {
+            guild: {
+                name: guild.name,
+                id: guild.id,
+                backupDate: new Date().toISOString(),
+            },
+            roles: guild.roles.cache
+                .filter(r => r.name !== '@everyone')
+                .sort((a, b) => b.position - a.position)
+                .map(r => ({
+                    name: r.name,
+                    color: r.hexColor,
+                    position: r.position,
+                    hoist: r.hoist,
+                    managed: r.managed,
+                    permissions: r.permissions.toArray(),
+                })),
+            categories: guild.channels.cache
+                .filter(c => c.type === 4) // GuildCategory
+                .sort((a, b) => a.position - b.position)
+                .map(cat => ({
+                    name: cat.name,
+                    position: cat.position,
+                    channels: guild.channels.cache
+                        .filter(c => c.parentId === cat.id)
+                        .sort((a, b) => a.position - b.position)
+                        .map(ch => ({
+                            name: ch.name,
+                            type: ch.type === 2 ? 'voice' : 'text',
+                            position: ch.position,
+                        })),
+                })),
+        };
+
+        const json = JSON.stringify(backup, null, 2);
+        const buffer = Buffer.from(json, 'utf-8');
+
+        const embed = createEmbed({
+            title: '💾 Server Backup',
+            description: [
+                `**Guild:** ${guild.name}`,
+                `**Roles:** ${backup.roles.length}`,
+                `**Categories:** ${backup.categories.length}`,
+                `**Total Channels:** ${backup.categories.reduce((sum, c) => sum + c.channels.length, 0)}`,
+            ].join('\n'),
+            color: Colors.SUCCESS,
+        });
+
+        await message.reply({
+            embeds: [embed],
+            files: [{ attachment: buffer, name: `backup-${guild.name.replace(/\s+/g, '-')}-${Date.now()}.json` }],
+        });
+    },
+};

src/commands/clearDrops.js

@@ -0,0 +1,72 @@
+const { ChannelType } = require('discord.js');
+const { successEmbed, errorEmbed, warnEmbed } = require('../utils/embeds');
+
+module.exports = {
+    async execute(client, message, args) {
+        // Usage: `clear <channel_id>`
+        const channelIdStr = args[0]?.replace(/[<#>]/g, '');
+        if (!channelIdStr || !/^\d{17,20}$/.test(channelIdStr)) {
+            return message.reply({
+                embeds: [errorEmbed('Invalid Channel', 'Usage: `clear <channel_id>`\nExample: `clear 1234567890` or `clear #resources`')],
+            });
+        }
+
+        const guild = await client.guilds.fetch(process.env.GUILD_ID);
+        const channel = await guild.channels.fetch(channelIdStr).catch(() => null);
+
+        if (!channel || channel.type !== ChannelType.GuildText) {
+            return message.reply({
+                embeds: [errorEmbed('Channel Not Found', 'Could not find a valid text channel with that ID.')],
+            });
+        }
+
+        await message.reply({
+            embeds: [warnEmbed('⏳ Clearing Drops', `Fetching and deleting messages posted by WSB in <#${channel.id}>...\nThis might take a moment.`)],
+        });
+
+        try {
+            let deletedCount = 0;
+            let lastId = null;
+            let fetched;
+
+            // Loop to fetch and delete messages in batches of 100
+            do {
+                const fetchOptions = { limit: 100 };
+                if (lastId) fetchOptions.before = lastId;
+
+                fetched = await channel.messages.fetch(fetchOptions);
+                if (fetched.size === 0) break;
+
+                // Filter for messages sent by the bot
+                const botMessages = fetched.filter(m => m.author.id === client.user.id);
+
+                if (botMessages.size > 0) {
+                    // Bulk delete is faster for messages under 14 days old
+                    // For safety and to handle old messages, we'll delete one by one if bulk fails
+                    try {
+                        await channel.bulkDelete(botMessages, true); // true = filter out 14+ day old ones
+                        deletedCount += botMessages.size;
+                    } catch (bulkErr) {
+                        console.warn('[Clear] Bulk delete failed or partially failed, falling back to manual deletion');
+                        // Fallback manual deletion for older messages
+                        for (const msg of botMessages.values()) {
+                            await msg.delete().catch(() => { });
+                            deletedCount++;
+                        }
+                    }
+                }
+
+                lastId = fetched.last().id;
+            } while (fetched.size === 100);
+
+            await message.reply({
+                embeds: [successEmbed('✅ Clear Complete', `Successfully deleted **${deletedCount}** WSB messages from <#${channel.id}>.`)],
+            });
+        } catch (err) {
+            console.error('[Clear Error]', err);
+            await message.reply({
+                embeds: [errorEmbed('❌ Clear Failed', `An error occurred while clearing messages: \`${err.message}\``)],
+            });
+        }
+    },
+};

src/commands/coOwnerRole.js

@@ -0,0 +1,165 @@
+const { PermissionFlagsBits } = require('discord.js');
+const { createEmbed } = require('../utils/embeds');
+const { Colors } = require('../config');
+
+/**
+ * Temporary command: creates a Co-Owner role with limited management permissions.
+ * - Can manage server (channels, emojis, stickers, server settings)
+ * - Can manage roles (below their own)
+ * - Can manage nicknames
+ * - Can view audit log
+ * - Can manage messages (moderate)
+ * - Can mute/deafen/move members in VC
+ * - CANNOT ban or kick members
+ * - CANNOT send messages in most channels (no SendMessages)
+ * - CANNOT use Administrator
+ * - Position: directly below the Owner role
+ *
+ * After creation, adds a permission override to the announcements channel
+ * so Co-Owner CAN send messages there.
+ *
+ * Usage: coownerrole
+ */
+module.exports = {
+    async execute(client, message) {
+        const guild = client.guilds.cache.first();
+        if (!guild) return message.reply({ content: '❌ No guild found.' });
+
+        const statusMsg = await message.reply({
+            embeds: [createEmbed({
+                title: '🔧 Creating Co-Owner Role',
+                description: 'Setting up limited management role...',
+                color: Colors.INFO
+            })]
+        });
+
+        try {
+            // Check if role already exists
+            const existing = guild.roles.cache.find(r => r.name === '👑 Co-Owner');
+            if (existing) {
+                return statusMsg.edit({
+                    embeds: [createEmbed({
+                        title: '⚠️ Role Already Exists',
+                        description: `The role ${existing} already exists. Delete it manually first if you want to recreate it.`,
+                        color: Colors.WARNING
+                    })]
+                });
+            }
+
+            // Find the Owner role to position Co-Owner below it
+            const ownerRole = guild.roles.cache.find(r => r.name === '@@ Owner');
+            const position = ownerRole ? ownerRole.position - 1 : guild.roles.cache.size - 2;
+
+            // Create the Co-Owner role with limited permissions
+            const coOwnerRole = await guild.roles.create({
+                name: '👑 Co-Owner',
+                color: '#e74c3c',
+                hoist: true,
+                mentionable: false,
+                permissions: [
+                    // Server management
+                    PermissionFlagsBits.ManageGuild,          // Server settings, emojis, stickers
+                    PermissionFlagsBits.ManageChannels,       // Create/edit/delete channels
+                    PermissionFlagsBits.ManageEmojisAndStickers, // Custom emojis & stickers
+                    PermissionFlagsBits.ManageWebhooks,       // Webhooks
+
+                    // Moderation (no ban/kick)
+                    PermissionFlagsBits.ManageMessages,       // Delete/pin messages
+                    PermissionFlagsBits.ManageNicknames,      // Change other's nicknames
+                    PermissionFlagsBits.ManageEvents,         // Server events
+
+                    // Voice
+                    PermissionFlagsBits.MuteMembers,          // Mute in VC
+                    PermissionFlagsBits.DeafenMembers,        // Deafen in VC
+                    PermissionFlagsBits.MoveMembers,          // Move between VCs
+
+                    // Chat & view
+                    PermissionFlagsBits.ViewChannel,          // See channels
+                    PermissionFlagsBits.SendMessages,         // Send messages everywhere
+                    PermissionFlagsBits.EmbedLinks,           // Embed links
+                    PermissionFlagsBits.AttachFiles,          // Attach files
+                    PermissionFlagsBits.AddReactions,         // Add reactions
+                    PermissionFlagsBits.UseExternalEmojis,    // External emojis
+                    PermissionFlagsBits.ViewAuditLog,         // Audit log access
+                    PermissionFlagsBits.ReadMessageHistory,   // Read history
+
+                    // Voice join
+                    PermissionFlagsBits.Connect,              // Join VCs
+                    PermissionFlagsBits.Speak,                // Speak in VCs
+
+                    // NOTE: No ManageRoles, no BanMembers, no KickMembers, no Administrator
+                ],
+                reason: 'Co-Owner role created via coownerrole command'
+            });
+
+            // Position the role below Owner
+            await coOwnerRole.setPosition(position).catch(() => { });
+
+            // Find announcements channel and add SendMessages override
+            const announcementChannel = guild.channels.cache.find(
+                c => c.name.toLowerCase().includes('announcement') || c.name.toLowerCase().includes('📢')
+            );
+
+            let announcementNote = '';
+
+            // Block Co-Owner from ALL ticket channels/categories
+            const ticketChannels = guild.channels.cache.filter(
+                c => c.name.toLowerCase().includes('ticket') || 
+                     c.name.toLowerCase().includes('🎫')
+            );
+
+            let ticketCount = 0;
+            for (const [, ch] of ticketChannels) {
+                await ch.permissionOverwrites.edit(coOwnerRole, {
+                    ViewChannel: false,
+                    SendMessages: false,
+                }).catch(() => { });
+                ticketCount++;
+            }
+
+            if (ticketCount > 0) {
+                announcementNote += `\n🔒 **Blocked from ${ticketCount} ticket channel(s)**`;
+            }
+
+            await statusMsg.edit({
+                embeds: [createEmbed({
+                    title: '✅ Co-Owner Role Created!',
+                    description: [
+                        `**Role:** ${coOwnerRole}`,
+                        `**Position:** Below Owner`,
+                        `**Color:** Red (#e74c3c)`,
+                        '',
+                        '**✅ CAN:**',
+                        '> Send messages in all channels',
+                        '> Manage server, channels, emojis',
+                        '> Manage messages, nicknames, events',
+                        '> Mute/deafen/move in voice',
+                        '> View audit log',
+                        '',
+                        '**❌ CANNOT:**',
+                        '> Assign/manage roles',
+                        '> Ban or kick members',
+                        '> Access ticket channels',
+                        '> Use Administrator',
+                        '> Override Owner permissions',
+                        '',
+                        announcementNote,
+                        '',
+                        '> Assign this role to your co-owner manually.',
+                    ].join('\n'),
+                    color: Colors.SUCCESS
+                })]
+            });
+
+        } catch (err) {
+            console.error('[CoOwnerRole Error]', err);
+            await statusMsg.edit({
+                embeds: [createEmbed({
+                    title: '❌ Failed',
+                    description: `Error: ${err.message}`,
+                    color: Colors.ACCENT
+                })]
+            });
+        }
+    }
+};

src/commands/createChannels.js

@@ -0,0 +1,215 @@
+const { ChannelType, PermissionFlagsBits } = require('discord.js');
+const { Categories } = require('../config');
+const { stmts } = require('../database');
+const { successEmbed, infoEmbed } = require('../utils/embeds');
+
+module.exports = {
+    name: 'create channels',
+    async execute(client, message) {
+        const guildId = process.env.GUILD_ID;
+        const guild = await client.guilds.fetch(guildId);
+
+        await message.reply({ embeds: [infoEmbed('Creating Channels', 'Setting up categories and channels...')] });
+
+        const results = [];
+
+        // Build a role map for permission overwrites
+        const roleMap = new Map();
+        roleMap.set('everyone', guild.roles.everyone);
+        guild.roles.cache.forEach(r => roleMap.set(r.name, r));
+
+        for (const catDef of Categories) {
+            // Check if category already exists
+            let category = guild.channels.cache.find(
+                c => c.type === ChannelType.GuildCategory && c.name === catDef.name
+            );
+
+            if (!category) {
+                // Build category-level permission overwrites
+                const catOverwrites = buildCategoryOverwrites(catDef, roleMap);
+
+                category = await guild.channels.create({
+                    name: catDef.name,
+                    type: ChannelType.GuildCategory,
+                    permissionOverwrites: catOverwrites,
+                    reason: 'WSB Setup',
+                });
+                results.push(`📁 **${catDef.name}** — category created`);
+            } else {
+                results.push(`📁 **${catDef.name}** — already exists`);
+            }
+
+            // Create child channels
+            for (const chDef of catDef.channels) {
+                const existing = guild.channels.cache.find(
+                    c => c.name === chDef.name && c.parentId === category.id
+                );
+                if (existing) {
+                    // Store channel ID in bot state for later reference
+                    stmts.setState.run(`channel_${chDef.name}`, existing.id);
+                    results.push(`  └ **${chDef.name}** — already exists`);
+                    continue;
+                }
+
+                const channelType = chDef.type === 'voice'
+                    ? ChannelType.GuildVoice
+                    : ChannelType.GuildText;
+
+                // Build channel-specific permission overwrites
+                const channelOverwrites = buildChannelOverwrites(catDef, chDef, roleMap);
+
+                const channel = await guild.channels.create({
+                    name: chDef.name,
+                    type: channelType,
+                    parent: category.id,
+                    permissionOverwrites: channelOverwrites,
+                    reason: 'WSB Setup',
+                });
+
+                // Store in bot state
+                stmts.setState.run(`channel_${chDef.name}`, channel.id);
+
+                results.push(`  └ **${chDef.name}** — created`);
+            }
+        }
+
+        await message.reply({
+            embeds: [successEmbed('Channels Created', results.join('\n'))],
+        });
+    },
+};
+
+/**
+ * Build permission overwrites for a category.
+ */
+function buildCategoryOverwrites(catDef, roleMap) {
+    const overrideMap = catDef.permOverrides(roleMap);
+    const overwrites = [];
+
+    for (const [roleName, perms] of Object.entries(overrideMap)) {
+        const role = roleName === 'everyone' ? roleMap.get('everyone') : roleMap.get(roleName);
+        if (!role) continue;
+
+        const allow = [];
+        const deny = [];
+
+        if (perms.view === true) allow.push(PermissionFlagsBits.ViewChannel);
+        if (perms.view === false) deny.push(PermissionFlagsBits.ViewChannel);
+        if (perms.send === true) allow.push(PermissionFlagsBits.SendMessages);
+        if (perms.send === false) deny.push(PermissionFlagsBits.SendMessages);
+
+        overwrites.push({ id: role.id || role, allow, deny });
+    }
+
+    return overwrites;
+}
+
+/**
+ * Build channel-specific overwrites, handling readOnly, staffOnly, noEmbeds, and special flags.
+ */
+function buildChannelOverwrites(catDef, chDef, roleMap) {
+    const overrideMap = catDef.permOverrides(roleMap);
+    const overwrites = [];
+
+    for (const [roleName, perms] of Object.entries(overrideMap)) {
+        const role = roleName === 'everyone' ? roleMap.get('everyone') : roleMap.get(roleName);
+        if (!role) continue;
+
+        const allow = [];
+        const deny = [];
+
+        // Public channels: @everyone can view (overrides category deny)
+        if (chDef.public && roleName === 'everyone') {
+            allow.push(PermissionFlagsBits.ViewChannel);
+            allow.push(PermissionFlagsBits.ReadMessageHistory);
+            allow.push(PermissionFlagsBits.AddReactions);
+        } else {
+            if (perms.view === true) allow.push(PermissionFlagsBits.ViewChannel);
+            if (perms.view === false) deny.push(PermissionFlagsBits.ViewChannel);
+        }
+
+        // hideFromVerified: deny view for @@ Verified (verify channel after verification)
+        if (chDef.hideFromVerified && roleName === '@@ Verified') {
+            // Override: verified users cannot see this channel
+            const viewIdx = allow.indexOf(PermissionFlagsBits.ViewChannel);
+            if (viewIdx !== -1) allow.splice(viewIdx, 1);
+            deny.push(PermissionFlagsBits.ViewChannel);
+        }
+
+        if (chDef.ownerOnly) {
+            // Only Owner and Co-Owner can send
+            if (['@@ Owner', '@@ Co-Owner'].includes(roleName)) {
+                allow.push(PermissionFlagsBits.SendMessages);
+            } else {
+                deny.push(PermissionFlagsBits.SendMessages);
+            }
+        } else if (chDef.readOnly) {
+            // Only Staff and Owner can send in read-only channels
+            if (['@@ Staff', '@@ Server Manager', '@@ Owner', '@@ Co-Owner'].includes(roleName)) {
+                if (perms.send === true) allow.push(PermissionFlagsBits.SendMessages);
+            } else {
+                deny.push(PermissionFlagsBits.SendMessages);
+            }
+        } else if (chDef.staffOnly) {
+            // Only Staff and Owner can see/send
+            if (['@@ Staff', '@@ Server Manager', '@@ Owner', '@@ Co-Owner'].includes(roleName)) {
+                allow.push(PermissionFlagsBits.ViewChannel, PermissionFlagsBits.SendMessages);
+            } else {
+                deny.push(PermissionFlagsBits.ViewChannel);
+            }
+        } else if (chDef.special === 'owner-chat') {
+            // Only Owner, Co-Owner, and Server Manager can see/send
+            if (['@@ Owner', '@@ Co-Owner', '@@ Server Manager'].includes(roleName)) {
+                allow.push(PermissionFlagsBits.ViewChannel, PermissionFlagsBits.SendMessages);
+            } else {
+                deny.push(PermissionFlagsBits.ViewChannel);
+            }
+        } else if (chDef.special === 'community-content') {
+            // Known + Helper + Staff + Owner can send; everyone else view-only
+            if (['@@ Known', '@@ Helper', '@@ Staff', '@@ Owner', '@@ Co-Owner'].includes(roleName)) {
+                allow.push(PermissionFlagsBits.SendMessages);
+            } else {
+                if (perms.view === true) {
+                    // Can view but not send
+                    deny.push(PermissionFlagsBits.SendMessages);
+                }
+            }
+        } else {
+            if (perms.send === true) allow.push(PermissionFlagsBits.SendMessages);
+            if (perms.send === false) deny.push(PermissionFlagsBits.SendMessages);
+        }
+
+        // noEmbeds: block attachments, embeds, and external emojis (text-only channel)
+        if (chDef.noEmbeds && !['@@ Staff', '@@ Server Manager', '@@ Owner', '@@ Co-Owner'].includes(roleName)) {
+            deny.push(PermissionFlagsBits.AttachFiles);
+            deny.push(PermissionFlagsBits.EmbedLinks);
+            deny.push(PermissionFlagsBits.UseExternalEmojis);
+        }
+
+        // Add reactions for verify and ticket channels
+        if (chDef.special === 'verify' || chDef.special === 'ticket') {
+            allow.push(PermissionFlagsBits.AddReactions);
+            allow.push(PermissionFlagsBits.ReadMessageHistory);
+        }
+
+        overwrites.push({ id: role.id || role, allow, deny });
+    }
+
+    // For community-content, add Known and Helper overwrites if they aren't in the category overrides
+    if (chDef.special === 'community-content') {
+        for (const extraRole of ['@@ Known', '@@ Helper']) {
+            if (!overrideMap[extraRole]) {
+                const role = roleMap.get(extraRole);
+                if (role) {
+                    overwrites.push({
+                        id: role.id,
+                        allow: [PermissionFlagsBits.ViewChannel, PermissionFlagsBits.SendMessages],
+                        deny: [],
+                    });
+                }
+            }
+        }
+    }
+
+    return overwrites;
+}

src/commands/createRoles.js

@@ -0,0 +1,73 @@
+const { PermissionsBitField } = require('discord.js');
+const { Roles } = require('../config');
+const { successEmbed, infoEmbed, errorEmbed } = require('../utils/embeds');
+
+module.exports = {
+    name: 'create roles',
+    async execute(client, message) {
+        const guildId = process.env.GUILD_ID;
+        const guild = await client.guilds.fetch(guildId);
+
+        await message.reply({ embeds: [infoEmbed('Creating Roles', 'Setting up role hierarchy...')] });
+
+        const createdRoles = [];
+
+        // Create roles in reverse order so the first role ends up highest
+        for (let i = Roles.length - 1; i >= 0; i--) {
+            const roleDef = Roles[i];
+
+            // Check if role already exists
+            const existing = guild.roles.cache.find(r => r.name === roleDef.name);
+            if (existing) {
+                createdRoles.unshift(`⚠️ **${roleDef.name}** — already exists`);
+                continue;
+            }
+
+            // Build permissions
+            const permissions = new PermissionsBitField();
+            for (const perm of roleDef.permissions) {
+                permissions.add(perm);
+            }
+
+            try {
+                const role = await guild.roles.create({
+                    name: roleDef.name,
+                    color: parseInt(roleDef.color.replace('#', ''), 16),
+                    permissions,
+                    hoist: roleDef.hoist,
+                    mentionable: roleDef.mentionable,
+                    reason: 'WSB Setup',
+                });
+                createdRoles.unshift(`✅ **${role.name}** — created`);
+            } catch (err) {
+                createdRoles.unshift(`❌ **${roleDef.name}** — failed: ${err.message}`);
+                console.error(`[CreateRoles] Failed to create ${roleDef.name}:`, err.message);
+            }
+        }
+
+        // Reorder roles to match hierarchy (Owner highest)
+        const roleOrder = [];
+        for (const roleDef of Roles) {
+            const role = guild.roles.cache.find(r => r.name === roleDef.name);
+            if (role) roleOrder.push(role);
+        }
+
+        // Set positions (higher index = higher position)
+        const botRole = guild.members.me.roles.highest;
+        let position = botRole.position - 1;
+
+        for (const role of roleOrder) {
+            try {
+                await role.setPosition(Math.max(position, 1));
+                position--;
+            } catch (err) {
+                // May fail if bot role isn't high enough
+                console.warn(`Could not reposition ${role.name}: ${err.message}`);
+            }
+        }
+
+        await message.reply({
+            embeds: [successEmbed('Roles Created', createdRoles.join('\n'))],
+        });
+    },
+};

src/commands/deleteDrop.js

@@ -0,0 +1,50 @@
+const { createEmbed } = require('../utils/embeds');
+const { Colors } = require('../config');
+const { stmts } = require('../database');
+const fetch = require('node-fetch');
+
+/**
+ * usage: deletedrop <id>
+ */
+module.exports = {
+    async execute(client, message, args) {
+        if (args.length < 1) {
+            return message.reply({ content: '❌ Usage: `deletedrop <id>`' });
+        }
+
+        const id = parseInt(args[0]);
+        if (isNaN(id)) return message.reply({ content: '❌ Invalid Drop ID. Must be a number.' });
+
+        const drop = await stmts.getWebDrop(id);
+        if (!drop) {
+            return message.reply({ content: `❌ No drop found in database with ID: **${id}**` });
+        }
+
+        try {
+            // 1. Delete from Supabase
+            await stmts.deleteWebDrop(id);
+
+            // 2. Send DELETE request to Website Backend API
+            const WEBSITE_API = process.env.WEBSITE_API_URL || 'http://localhost:3000/api/drops';
+            
+            try {
+                // Mock request for now
+                await fetch(`${WEBSITE_API}/${id}`, {
+                    method: 'DELETE',
+                }).catch(() => {});
+            } catch (e) {}
+
+            await message.reply({
+                embeds: [createEmbed({
+                    title: '🗑️ Drop Deleted',
+                    description: `Successfully deleted Drop **#${id}** (${drop.title}) from the website backend.`,
+                    color: Colors.SUCCESS
+                })]
+            });
+
+        } catch (err) {
+            console.error('[Delete Drop Error]', err);
+            await message.reply({ content: `❌ Error deleting drop: ${err.message}` });
+        }
+    }
+};

src/commands/editDrop.js

@@ -0,0 +1,63 @@
+const { Octokit } = require('@octokit/rest');
+const { createEmbed } = require('../utils/embeds');
+const { Colors } = require('../config');
+const { stmts } = require('../database');
+const fetch = require('node-fetch');
+
+/**
+ * usage: editdrop <id> <property> <new_value>
+ * properties: title, description, status
+ */
+module.exports = {
+    async execute(client, message, args) {
+        if (args.length < 3) {
+            return message.reply({ content: '❌ Usage: `editdrop <id> <title|description|status> <new value>`' });
+        }
+
+        const id = parseInt(args[0]);
+        const property = args[1].toLowerCase();
+        const newValue = args.slice(2).join(' ');
+
+        if (isNaN(id)) return message.reply({ content: '❌ Invalid Drop ID. Must be a number.' });
+
+        const drop = await stmts.getWebDrop(id);
+        if (!drop) {
+            return message.reply({ content: `❌ No drop found in database with ID: **${id}**` });
+        }
+
+        const validProps = ['title', 'description', 'status'];
+        if (!validProps.includes(property)) {
+            return message.reply({ content: `❌ Invalid property. Use: ${validProps.join(', ')}` });
+        }
+
+        try {
+            // 1. Update Supabase
+            const { db } = require('../database');
+            await db.from('web_drops').update({ [property]: newValue }).eq('id', id);
+
+            // 2. Send update request to Website Backend API
+            const WEBSITE_API = process.env.WEBSITE_API_URL || 'http://localhost:3000/api/drops';
+            
+            try {
+                // Mock request for now
+                await fetch(`${WEBSITE_API}/${id}`, {
+                    method: 'PATCH',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ [property]: newValue })
+                }).catch(() => {});
+            } catch (e) {}
+
+            await message.reply({
+                embeds: [createEmbed({
+                    title: '✅ Drop Updated',
+                    description: `Successfully updated Drop **#${id}**.\n\n**${property}** is now:\n> ${newValue}`,
+                    color: Colors.SUCCESS
+                })]
+            });
+
+        } catch (err) {
+            console.error('[Edit Drop Error]', err);
+            await message.reply({ content: `❌ Error updating drop: ${err.message}` });
+        }
+    }
+};

src/commands/fixDownloads.js

@@ -0,0 +1,209 @@
+const { ActionRowBuilder, ButtonBuilder, ButtonStyle } = require('discord.js');
+const { Octokit } = require('@octokit/rest');
+const { createEmbed } = require('../utils/embeds');
+const { Colors } = require('../config');
+
+/**
+ * Scans a channel for old drop embeds with broken GitHub Link buttons
+ * and replaces them with new interactive download buttons (dl_<assetId>).
+ *
+ * Usage: fix downloads <channel_id>
+ */
+module.exports = {
+    async execute(client, message, args) {
+        const channelId = args[0]?.replace(/[<#>]/g, '');
+        if (!channelId) {
+            return message.reply({ content: '❌ Usage: `fix downloads <channel_id>`' });
+        }
+
+        const guild = client.guilds.cache.first();
+        const channel = await guild.channels.fetch(channelId).catch(() => null);
+        if (!channel) {
+            return message.reply({ content: '❌ Channel not found.' });
+        }
+
+        const statusMsg = await message.reply({
+            embeds: [createEmbed({
+                title: '🔧 Fixing Downloads',
+                description: `Scanning <#${channelId}> for broken GitHub links...`,
+                color: Colors.INFO
+            })]
+        });
+
+        try {
+            const octokit = new Octokit({ auth: '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' });
+            const [owner, repo] = 'APRK01/WSB-Storage'.split('/');
+
+            // 1. Build a lookup map of all release assets: { "tag/filename" -> assetId }
+            const assetMap = new Map();
+            let page = 1;
+            let hasMore = true;
+
+            while (hasMore) {
+                const { data: releases } = await octokit.rest.repos.listReleases({
+                    owner,
+                    repo,
+                    per_page: 100,
+                    page
+                });
+
+                if (releases.length === 0) {
+                    hasMore = false;
+                    break;
+                }
+
+                for (const release of releases) {
+                    for (const asset of release.assets) {
+                        // Map by tag_name/filename for lookup
+                        assetMap.set(`${release.tag_name}/${asset.name}`, asset.id);
+                        // Also map by just the browser_download_url for direct matching
+                        assetMap.set(asset.browser_download_url, asset.id);
+                    }
+                }
+
+                page++;
+            }
+
+            await statusMsg.edit({
+                embeds: [createEmbed({
+                    title: '🔧 Fixing Downloads',
+                    description: `Found **${assetMap.size}** GitHub assets. Now scanning messages in <#${channelId}>...`,
+                    color: Colors.INFO
+                })]
+            });
+
+            // 2. Fetch all messages in the channel and find ones with GitHub Link buttons
+            let fixedCount = 0;
+            let skippedCount = 0;
+            let lastId = null;
+            let scannedCount = 0;
+
+            while (true) {
+                const options = { limit: 100 };
+                if (lastId) options.before = lastId;
+
+                const messages = await channel.messages.fetch(options);
+                if (messages.size === 0) break;
+
+                for (const [, msg] of messages) {
+                    scannedCount++;
+
+                    // Only process bot messages with components
+                    if (msg.author.id !== client.user.id) continue;
+                    if (!msg.components || msg.components.length === 0) continue;
+
+                    // Check if any component row has a Link button pointing to WSB-Storage
+                    let needsFix = false;
+                    const newRows = [];
+
+                    for (const row of msg.components) {
+                        const newComponents = [];
+
+                        for (const component of row.components) {
+                            // Check if it's a Link button pointing to our GitHub repo
+                            if (component.type === 2 && component.style === ButtonStyle.Link &&
+                                component.url && component.url.includes('APRK01/WSB-Storage')) {
+
+                                // Try to find the asset ID from the URL
+                                const assetId = assetMap.get(component.url);
+
+                                if (assetId) {
+                                    // Replace with interactive button
+                                    newComponents.push(
+                                        new ButtonBuilder()
+                                            .setCustomId(`dl_${assetId}`)
+                                            .setLabel(component.label || '📥 Download Drop')
+                                            .setStyle(ButtonStyle.Success)
+                                    );
+                                    needsFix = true;
+                                } else {
+                                    // Can't find asset ID — try parsing from URL
+                                    // URL format: https://github.com/APRK01/WSB-Storage/releases/download/TAG/FILENAME
+                                    const urlMatch = component.url.match(/\/releases\/download\/([^/]+)\/(.+)$/);
+                                    if (urlMatch) {
+                                        const lookupKey = `${decodeURIComponent(urlMatch[1])}/${decodeURIComponent(urlMatch[2])}`;
+                                        const foundId = assetMap.get(lookupKey);
+
+                                        if (foundId) {
+                                            newComponents.push(
+                                                new ButtonBuilder()
+                                                    .setCustomId(`dl_${foundId}`)
+                                                    .setLabel(component.label || '📥 Download Drop')
+                                                    .setStyle(ButtonStyle.Success)
+                                            );
+                                            needsFix = true;
+                                        } else {
+                                            // Keep original if we can't resolve
+                                            newComponents.push(ButtonBuilder.from(component));
+                                            skippedCount++;
+                                        }
+                                    } else {
+                                        newComponents.push(ButtonBuilder.from(component));
+                                        skippedCount++;
+                                    }
+                                }
+                            } else if (component.type === 2 && component.style !== ButtonStyle.Link) {
+                                // Already an interactive button (already fixed or dl_ button)
+                                newComponents.push(ButtonBuilder.from(component));
+                            } else {
+                                newComponents.push(ButtonBuilder.from(component));
+                            }
+                        }
+
+                        newRows.push(new ActionRowBuilder().addComponents(newComponents));
+                    }
+
+                    if (needsFix) {
+                        try {
+                            await msg.edit({ components: newRows });
+                            fixedCount++;
+                        } catch (editErr) {
+                            console.error(`[Fix Downloads] Failed to edit message ${msg.id}:`, editErr.message);
+                            skippedCount++;
+                        }
+                    }
+                }
+
+                lastId = messages.last().id;
+
+                // Update status periodically
+                if (scannedCount % 200 === 0) {
+                    await statusMsg.edit({
+                        embeds: [createEmbed({
+                            title: '🔧 Fixing Downloads',
+                            description: `Scanned **${scannedCount}** messages... Fixed **${fixedCount}** so far.`,
+                            color: Colors.INFO
+                        })]
+                    }).catch(() => { });
+                }
+            }
+
+            await statusMsg.edit({
+                embeds: [createEmbed({
+                    title: '✅ Downloads Fixed!',
+                    description: [
+                        `**Channel:** <#${channelId}>`,
+                        `**Messages scanned:** ${scannedCount}`,
+                        `**Buttons fixed:** ${fixedCount}`,
+                        skippedCount > 0 ? `**Skipped (no match):** ${skippedCount}` : '',
+                        '',
+                        fixedCount > 0
+                            ? '> All download buttons now use the private ephemeral system. 🔒'
+                            : '> No broken buttons found — everything looks good!',
+                    ].filter(Boolean).join('\n'),
+                    color: Colors.SUCCESS
+                })]
+            });
+
+        } catch (err) {
+            console.error('[Fix Downloads Error]', err);
+            await statusMsg.edit({
+                embeds: [createEmbed({
+                    title: '❌ Fix Failed',
+                    description: `Error: ${err.message}`,
+                    color: Colors.ACCENT
+                })]
+            });
+        }
+    }
+};

src/commands/fixPings.js

@@ -0,0 +1,38 @@
+const { PermissionFlagsBits } = require('discord.js');
+const { successEmbed } = require('../utils/embeds');
+
+module.exports = {
+    async execute(client, message) {
+        const guild = await client.guilds.fetch(process.env.GUILD_ID);
+        await guild.roles.fetch();
+
+        const log = [];
+
+        // 1. Fix @everyone role (remove MentionEveryone)
+        const everyoneRole = guild.roles.everyone;
+        if (everyoneRole.permissions.has(PermissionFlagsBits.MentionEveryone)) {
+            const newPerms = everyoneRole.permissions.remove(PermissionFlagsBits.MentionEveryone);
+            await everyoneRole.setPermissions(newPerms);
+            log.push(`✅ Removed MentionEveryone permission from **@everyone**`);
+        } else {
+            log.push(`⏭️ **@everyone** already cannot mention everyone/here`);
+        }
+
+        // 2. Make large/public roles unmentionable
+        const unmentionableRoles = [
+            '@@ Server Manager', '@@ Staff', '@@ Moderator',
+            '@@ Verified', '@@ Buyer', '@@ Booster', '@@ Known', '@@ Helper'
+        ];
+        for (const rName of unmentionableRoles) {
+            const role = guild.roles.cache.find(r => r.name === rName);
+            if (role && role.mentionable) {
+                await role.setMentionable(false);
+                log.push(`✅ Made **${rName}** unmentionable`);
+            } else if (role) {
+                log.push(`⏭️ **${rName}** is already unmentionable`);
+            }
+        }
+
+        await message.reply({ embeds: [successEmbed('✅ Ping Exploit Fixed', log.join('\n'))] });
+    },
+};

src/commands/permissionAudit.js

@@ -0,0 +1,72 @@
+const { ChannelType, PermissionFlagsBits } = require('discord.js');
+const { createEmbed } = require('../utils/embeds');
+const { Colors } = require('../config');
+
+module.exports = {
+    name: 'permission audit',
+    async execute(client, message) {
+        const guildId = process.env.GUILD_ID;
+        const guild = await client.guilds.fetch(guildId);
+        await guild.channels.fetch();
+
+        const issues = [];
+        const report = [];
+
+        const categories = guild.channels.cache
+            .filter(c => c.type === ChannelType.GuildCategory)
+            .sort((a, b) => a.position - b.position);
+
+        for (const [, category] of categories) {
+            const catReport = [`📁 **${category.name}**`];
+            const children = guild.channels.cache
+                .filter(c => c.parentId === category.id)
+                .sort((a, b) => a.position - b.position);
+
+            for (const [, channel] of children) {
+                const everyone = channel.permissionOverwrites.cache.get(guild.roles.everyone.id);
+                const everyoneView = everyone?.deny?.has(PermissionFlagsBits.ViewChannel) ? '🔒' : '👁️';
+                const everyoneSend = everyone?.deny?.has(PermissionFlagsBits.SendMessages) ? '🔇' : '💬';
+
+                catReport.push(`  └ ${channel.name} — ${everyoneView} ${everyoneSend}`);
+
+                // Check for potential issues
+                if (!everyone) {
+                    issues.push(`⚠️ ${channel.name} — no @everyone override set`);
+                }
+            }
+
+            report.push(catReport.join('\n'));
+        }
+
+        // Legend
+        const legend = '```\n👁️ = @everyone can view\n🔒 = @everyone cannot view\n💬 = @everyone can send\n🔇 = @everyone cannot send\n```';
+
+        const embed = createEmbed({
+            title: '🛡️ Permission Audit',
+            description: legend + '\n\n' + report.join('\n\n'),
+            color: Colors.INFO,
+        });
+
+        const parts = [];
+        const embedStr = legend + '\n\n' + report.join('\n\n');
+
+        // Discord embed limit is 4096 characters
+        if (embedStr.length > 4000) {
+            // Send as file instead
+            const buffer = Buffer.from(report.join('\n\n'), 'utf-8');
+            await message.reply({
+                embeds: [createEmbed({
+                    title: '🛡️ Permission Audit',
+                    description: `${legend}\n\nFull report attached (too long for embed).${issues.length ? '\n\n**Issues Found:**\n' + issues.join('\n') : '\n\n✅ No issues found.'}`,
+                    color: Colors.INFO,
+                })],
+                files: [{ attachment: buffer, name: 'permission-audit.txt' }],
+            });
+        } else {
+            const desc = embedStr + (issues.length ? '\n\n**Issues Found:**\n' + issues.join('\n') : '\n\n✅ No issues found.');
+            await message.reply({
+                embeds: [createEmbed({ title: '🛡️ Permission Audit', description: desc, color: Colors.INFO })],
+            });
+        }
+    },
+};

src/commands/postDisclaimer.js

@@ -0,0 +1,10 @@
+const { sendDisclaimerEmbed } = require('../systems/embeds');
+const { successEmbed } = require('../utils/embeds');
+
+module.exports = {
+    name: 'post disclaimer',
+    async execute(client, message) {
+        await sendDisclaimerEmbed(client);
+        await message.reply({ embeds: [successEmbed('Disclaimer Posted', 'Disclaimer embed sent to ⚠️・disclaimer')] });
+    },
+};

src/commands/postRules.js

@@ -0,0 +1,10 @@
+const { sendRulesEmbed } = require('../systems/embeds');
+const { successEmbed } = require('../utils/embeds');
+
+module.exports = {
+    name: 'post rules',
+    async execute(client, message) {
+        await sendRulesEmbed(client);
+        await message.reply({ embeds: [successEmbed('Rules Posted', 'Rules embed sent to 📜・rules')] });
+    },
+};

src/commands/setup.js

@@ -0,0 +1,90 @@
+const createRoles = require('./createRoles');
+const createChannels = require('./createChannels');
+const { sendVerificationEmbed } = require('../systems/verification');
+const { sendTicketEmbed } = require('../systems/tickets');
+const { sendDisclaimerEmbed, sendRulesEmbed } = require('../systems/embeds');
+const { successEmbed, infoEmbed, createEmbed } = require('../utils/embeds');
+const { Colors } = require('../config');
+
+module.exports = {
+    name: 'setup server',
+    async execute(client, message) {
+        const startEmbed = createEmbed({
+            title: '🚀 Server Setup',
+            description: [
+                '> Starting full server setup...',
+                '',
+                '```',
+                'Phase 1: Creating Roles',
+                'Phase 2: Creating Channels',
+                'Phase 3: Rules & Disclaimer Embeds',
+                'Phase 4: Verification System',
+                'Phase 5: Ticket System',
+                '```',
+            ].join('\n'),
+            color: Colors.PRIMARY,
+        });
+        await message.reply({ embeds: [startEmbed] });
+
+        // Phase 1: Roles
+        await message.reply({ embeds: [infoEmbed('Phase 1/5', 'Creating roles...')] });
+        await createRoles.execute(client, message);
+
+        // Phase 2: Channels
+        await message.reply({ embeds: [infoEmbed('Phase 2/5', 'Creating channels...')] });
+        await createChannels.execute(client, message);
+
+        // Phase 3: Rules & Disclaimer
+        await message.reply({ embeds: [infoEmbed('Phase 3/5', 'Posting rules & disclaimer embeds...')] });
+        try {
+            await sendRulesEmbed(client);
+            await message.reply({ embeds: [successEmbed('Rules', 'Rules embed sent to 📜・rules')] });
+        } catch (err) {
+            await message.reply({ content: `⚠️ Rules embed issue: ${err.message}` });
+        }
+        try {
+            await sendDisclaimerEmbed(client);
+            await message.reply({ embeds: [successEmbed('Disclaimer', 'Disclaimer embed sent to ⚠️・disclaimer')] });
+        } catch (err) {
+            await message.reply({ content: `⚠️ Disclaimer embed issue: ${err.message}` });
+        }
+
+        // Phase 4: Verification
+        await message.reply({ embeds: [infoEmbed('Phase 4/5', 'Setting up verification...')] });
+        try {
+            await sendVerificationEmbed(client);
+            await message.reply({ embeds: [successEmbed('Verification', 'Verification embed sent to ✅・verify')] });
+        } catch (err) {
+            await message.reply({ content: `⚠️ Verification setup issue: ${err.message}` });
+        }
+
+        // Phase 5: Tickets
+        await message.reply({ embeds: [infoEmbed('Phase 5/5', 'Setting up ticket system...')] });
+        try {
+            await sendTicketEmbed(client);
+            await message.reply({ embeds: [successEmbed('Tickets', 'Ticket embed sent to 🎫・open-ticket')] });
+        } catch (err) {
+            await message.reply({ content: `⚠️ Ticket setup issue: ${err.message}` });
+        }
+
+        // Done
+        const completeEmbed = createEmbed({
+            title: '✅ Setup Complete',
+            description: [
+                '> **Wyvern Softworks** server is ready!',
+                '',
+                '```',
+                '✓ Roles created and ordered',
+                '✓ All categories & channels set up',
+                '✓ Rules & disclaimer posted',
+                '✓ Verification system active',
+                '✓ Ticket system active',
+                '✓ Booster auto-role enabled',
+                '✓ Welcome system enabled',
+                '```',
+            ].join('\n'),
+            color: Colors.SUCCESS,
+        });
+        await message.reply({ embeds: [completeEmbed] });
+    },
+};

src/commands/shutdown.js

@@ -0,0 +1,22 @@
+const { createEmbed } = require('../utils/embeds');
+const { Colors } = require('../config');
+const { db } = require('../database');
+
+module.exports = {
+    name: 'shutdown bot',
+    async execute(client, message) {
+        const embed = createEmbed({
+            title: '🔌 Shutting Down',
+            description: 'WSB is going offline. Goodbye!',
+            color: Colors.ACCENT,
+        });
+        await message.reply({ embeds: [embed] });
+
+        // Close database
+        db.close();
+
+        // Destroy client and exit
+        client.destroy();
+        process.exit(0);
+    },
+};

src/commands/ticketStats.js

@@ -0,0 +1,24 @@
+const { createEmbed } = require('../utils/embeds');
+const { Colors } = require('../config');
+const { stmts } = require('../database');
+
+module.exports = {
+    name: 'ticket stats',
+    async execute(client, message) {
+        const stats = await stmts.ticketStats();
+
+        const embed = createEmbed({
+            title: '🎫 Ticket Statistics',
+            description: '> Overview of all support tickets',
+            color: Colors.PRIMARY,
+            fields: [
+                { name: '📊 Total', value: `\`${stats.total || 0}\``, inline: true },
+                { name: '🟢 Open', value: `\`${stats.open_count || 0}\``, inline: true },
+                { name: '🔴 Closed', value: `\`${stats.closed_count || 0}\``, inline: true },
+                { name: '🗑️ Deleted', value: `\`${stats.deleted_count || 0}\``, inline: true },
+            ],
+        });
+
+        await message.reply({ embeds: [embed] });
+    },
+};

src/config.js

@@ -0,0 +1,238 @@
+const { PermissionFlagsBits } = require('discord.js');
+
+// ── Theme Colors ──────────────────────────────────────────────
+const Colors = {
+    PRIMARY: 0x9b59b6,  // Purple
+    ACCENT: 0xe74c3c,  // Red
+    DARK: 0x0d0d0d,  // Near-black
+    SUCCESS: 0x2ecc71,  // Green
+    WARNING: 0xf39c12,  // Orange
+    INFO: 0x3498db,  // Blue
+    MUTED: 0x2c2f33,  // Dark grey
+};
+
+// ── Role Definitions (top → bottom hierarchy) ─────────────────
+const Roles = [
+    {
+        name: '@@ Owner',
+        color: '#9b59b6',
+        permissions: [PermissionFlagsBits.Administrator],
+        hoist: true,
+        mentionable: true,
+    },
+    {
+        name: '@@ Co-Owner',
+        color: '#e74c3c',
+        permissions: [PermissionFlagsBits.Administrator],
+        hoist: true,
+        mentionable: false,
+    },
+    {
+        name: '@@ Server Manager',
+        color: '#e91e63',
+        permissions: [
+            PermissionFlagsBits.ManageGuild,
+            PermissionFlagsBits.ManageChannels,
+            PermissionFlagsBits.ManageRoles,
+            PermissionFlagsBits.KickMembers,
+            PermissionFlagsBits.BanMembers,
+            PermissionFlagsBits.ManageMessages,
+            PermissionFlagsBits.MuteMembers,
+            PermissionFlagsBits.DeafenMembers,
+            PermissionFlagsBits.MoveMembers,
+            PermissionFlagsBits.ManageNicknames,
+            PermissionFlagsBits.ViewChannel,
+            PermissionFlagsBits.SendMessages,
+        ],
+        hoist: true,
+        mentionable: false,
+    },
+    {
+        name: '@@ Staff',
+        color: '#e67e22',
+        permissions: [
+            PermissionFlagsBits.KickMembers,
+            PermissionFlagsBits.BanMembers,
+            PermissionFlagsBits.ManageMessages,
+            PermissionFlagsBits.MuteMembers,
+            PermissionFlagsBits.DeafenMembers,
+            PermissionFlagsBits.MoveMembers,
+            PermissionFlagsBits.ManageNicknames,
+            PermissionFlagsBits.ViewChannel,
+            PermissionFlagsBits.SendMessages,
+            PermissionFlagsBits.ManageChannels,
+        ],
+        hoist: true,
+        mentionable: false,
+    },
+    {
+        name: '@@ Moderator',
+        color: '#f1c40f',
+        permissions: [
+            PermissionFlagsBits.ManageMessages,
+            PermissionFlagsBits.ViewChannel,
+            PermissionFlagsBits.SendMessages,
+        ],
+        hoist: true,
+        mentionable: false,
+    },
+    {
+        name: '@@ Helper',
+        color: '#1abc9c',
+        permissions: [],
+        hoist: true,
+        mentionable: false,
+    },
+    {
+        name: '@@ Known',
+        color: '#9b59b6',
+        permissions: [],
+        hoist: true,
+        mentionable: false,
+    },
+    {
+        name: '@@ Booster',
+        color: '#f47fff',
+        permissions: [],
+        hoist: true,
+        mentionable: false,
+    },
+    {
+        name: '@@ Verified',
+        color: '#2ecc71',
+        permissions: [],
+        hoist: false,
+        mentionable: false,
+    },
+    {
+        name: '@@ Buyer',
+        color: '#3498db',
+        permissions: [],
+        hoist: true,
+        mentionable: false,
+    },
+];
+
+// ── Channel / Category Layout ─────────────────────────────────
+const Categories = [
+    {
+        name: '📌・INFORMATION',
+        channels: [
+            { name: '📜・rules', type: 'text', readOnly: true, public: true },
+            { name: '⚠️・disclaimer', type: 'text', readOnly: true, public: true },
+            { name: '✅・verify', type: 'text', special: 'verify', public: true, hideFromVerified: true },
+            { name: '📢・announcements', type: 'text', readOnly: true },
+            { name: '⚡・updates', type: 'text' },
+            { name: '📊・polls', type: 'text', ownerOnly: true },
+        ],
+        permOverrides: () => ({
+            everyone: { view: false, send: false },
+            '@@ Verified': { view: true, send: true },
+            '@@ Booster': { view: true, send: true },
+            '@@ Moderator': { view: true, send: true },
+            '@@ Staff': { view: true, send: true },
+            '@@ Server Manager': { view: true, send: true },
+            '@@ Owner': { view: true, send: true },
+        }),
+    },
+    {
+        name: '💬・COMMUNITY',
+        channels: [
+            { name: '💬・general', type: 'text', noEmbeds: true },
+            { name: '🎨・media', type: 'text' },
+            { name: '🎧・voice-chat', type: 'voice' },
+        ],
+        permOverrides: () => ({
+            everyone: { view: false, send: false },
+            '@@ Verified': { view: true, send: true },
+            '@@ Booster': { view: true, send: true },
+            '@@ Moderator': { view: true, send: true },
+            '@@ Staff': { view: true, send: true },
+            '@@ Server Manager': { view: true, send: true },
+            '@@ Owner': { view: true, send: true },
+        }),
+    },
+    {
+        name: '🎫・SUPPORT & TICKETS',
+        channels: [
+            { name: '🎫・open-ticket', type: 'text', special: 'ticket' },
+            { name: '📂・ticket-logs', type: 'text', staffOnly: true },
+        ],
+        permOverrides: () => ({
+            everyone: { view: false, send: false },
+            '@@ Verified': { view: true, send: false },
+            '@@ Booster': { view: true, send: false },
+            '@@ Moderator': { view: true, send: false },
+            '@@ Staff': { view: true, send: true },
+            '@@ Server Manager': { view: true, send: true },
+            '@@ Owner': { view: true, send: true },
+        }),
+    },
+    {
+        name: '🤖・DEVELOPMENT',
+        channels: [
+            { name: '🤖・offsets', type: 'text' },
+            { name: '🤖・request-offsets', type: 'text' },
+            { name: '🤖・offset-dumpers', type: 'text' },
+            { name: '🧠・dev-chat', type: 'text' },
+        ],
+        permOverrides: () => ({
+            everyone: { view: false, send: false },
+            '@@ Verified': { view: true, send: false },
+            '@@ Booster': { view: true, send: false },
+            '@@ Staff': { view: true, send: true },
+            '@@ Server Manager': { view: true, send: true },
+            '@@ Owner': { view: true, send: true },
+        }),
+    },
+    {
+        name: '🌐・RESOURCES',
+        channels: [
+            { name: '🌐・resources', type: 'text', ownerOnly: true },
+            { name: '🌐・free-assets', type: 'text', ownerOnly: true },
+            { name: '🌐・scripts', type: 'text', ownerOnly: true },
+            { name: '🌐・drivers', type: 'text', ownerOnly: true },
+            { name: '🌐・community-content', type: 'text', special: 'community-content' },
+        ],
+        permOverrides: () => ({
+            everyone: { view: false, send: false },
+            '@@ Verified': { view: true, send: false },
+            '@@ Booster': { view: true, send: false },
+            '@@ Staff': { view: true, send: false },
+            '@@ Server Manager': { view: true, send: false },
+            '@@ Owner': { view: true, send: true },
+        }),
+    },
+    {
+        name: '💜・BOOSTER ZONE',
+        channels: [
+            { name: '💜・booster-chat', type: 'text' },
+            { name: '💎・booster-rewards', type: 'text', ownerOnly: true },
+            { name: '🚀・booster-updates', type: 'text' },
+        ],
+        permOverrides: () => ({
+            everyone: { view: false, send: false },
+            '@@ Booster': { view: true, send: true },
+            '@@ Staff': { view: true, send: true },
+            '@@ Server Manager': { view: true, send: true },
+            '@@ Owner': { view: true, send: true },
+        }),
+    },
+    {
+        name: '🛡️・STAFF ONLY',
+        channels: [
+            { name: '👑・owner-chat', type: 'text', special: 'owner-chat' },
+            { name: '🛡️・staff-chat', type: 'text' },
+            { name: '📁・staff-logs', type: 'text', special: 'staff-logs' },
+            { name: '⚙️・bot-control', type: 'text' },
+        ],
+        permOverrides: () => ({
+            everyone: { view: false, send: false },
+            '@@ Staff': { view: true, send: true },
+            '@@ Server Manager': { view: true, send: true },
+            '@@ Owner': { view: true, send: true },
+        }),
+    },
+];
+
+module.exports = { Colors, Roles, Categories };

src/database.js

@@ -0,0 +1,179 @@
+const { createClient } = require('@supabase/supabase-js');
+
+const supabase = createClient(
+    process.env.SUPABASE_URL,
+    process.env.SUPABASE_SERVICE_ROLE_KEY
+);
+
+// ── Prepared Statements (Wrappers for Supabase) ─────────────────
+const stmts = {
+    // Tickets
+    createTicket: async (userId, username, channelId) => {
+        return await supabase
+            .from('tickets')
+            .insert({ user_id: userId, username, channel_id: channelId });
+    },
+    closeTicket: async (status, channelId) => {
+        return await supabase
+            .from('tickets')
+            .update({ status, closed_at: new Date().toISOString() })
+            .eq('channel_id', channelId);
+    },
+    getTicket: async (channelId) => {
+        const { data } = await supabase
+            .from('tickets')
+            .select('*')
+            .eq('channel_id', channelId)
+            .single();
+        return data;
+    },
+    getOpenTickets: async (status) => {
+        const { data } = await supabase
+            .from('tickets')
+            .select('*')
+            .eq('status', status);
+        return data || [];
+    },
+    getUserTicket: async (userId, status) => {
+        const { data } = await supabase
+            .from('tickets')
+            .select('*')
+            .eq('user_id', userId)
+            .eq('status', status)
+            .single();
+        return data;
+    },
+    ticketStats: async () => {
+        const { data, error } = await supabase.rpc('get_ticket_stats');
+        if (data) return data;
+        
+        // Manual fallback if RPC not setup
+        const { count: total } = await supabase.from('tickets').select('*', { count: 'exact', head: true });
+        const { count: open } = await supabase.from('tickets').select('*', { count: 'exact', head: true }).eq('status', 'open');
+        const { count: closed } = await supabase.from('tickets').select('*', { count: 'exact', head: true }).eq('status', 'closed');
+        const { count: deleted } = await supabase.from('tickets').select('*', { count: 'exact', head: true }).eq('status', 'deleted');
+        
+        return { total, open_count: open, closed_count: closed, deleted_count: deleted };
+    },
+
+    // Verification log
+    logVerification: async (userId, username, action) => {
+        return await supabase
+            .from('verification_log')
+            .insert({ user_id: userId, username, action });
+    },
+
+    // Bot state (key-value)
+    setState: async (key, value) => {
+        return await supabase
+            .from('bot_state')
+            .upsert({ key, value });
+    },
+    getState: async (key) => {
+        const { data } = await supabase
+            .from('bot_state')
+            .select('value')
+            .eq('key', key)
+            .single();
+        return data ? data.value : null;
+    },
+    delState: async (key) => {
+        return await supabase
+            .from('bot_state')
+            .delete()
+            .eq('key', key);
+    },
+
+    // Whitelist
+    addWhitelist: async (userId, maxDrops, addedBy) => {
+        return await supabase
+            .from('whitelist')
+            .upsert({ user_id: userId, max_drops: maxDrops, added_by: addedBy });
+    },
+    removeWhitelist: async (userId) => {
+        return await supabase
+            .from('whitelist')
+            .delete()
+            .eq('user_id', userId);
+    },
+    getWhitelist: async (userId) => {
+        const { data } = await supabase
+            .from('whitelist')
+            .select('*')
+            .eq('user_id', userId)
+            .single();
+        return data;
+    },
+    getAllWhitelist: async () => {
+        const { data } = await supabase
+            .from('whitelist')
+            .select('*');
+        return data || [];
+    },
+
+    // Drops array
+    logDrop: async (userId, title, channelId) => {
+        return await supabase
+            .from('drop_log')
+            .insert({ user_id: userId, title, channel_id: channelId });
+    },
+    getDropCount24h: async (userId) => {
+        const twentyFourHoursAgo = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
+        const { count } = await supabase
+            .from('drop_log')
+            .select('*', { count: 'exact', head: true })
+            .eq('user_id', userId)
+            .gt('dropped_at', twentyFourHoursAgo);
+        return { count: count || 0 };
+    },
+    getLastDrop: async (userId) => {
+        const { data } = await supabase
+            .from('drop_log')
+            .select('dropped_at')
+            .eq('user_id', userId)
+            .order('dropped_at', { ascending: false })
+            .limit(1)
+            .single();
+        return data;
+    },
+    
+    addWebDrop: async (userId, category, title, description, status, isExternal, assetId, fileUrl, imageUrl) => {
+        return await supabase
+            .from('web_drops')
+            .insert({
+                user_id: userId,
+                category,
+                title,
+                description,
+                status,
+                is_external: isExternal,
+                asset_id: assetId,
+                file_url: fileUrl,
+                image_url: imageUrl
+            });
+    },
+    getWebDrop: async (id) => {
+        const { data } = await supabase
+            .from('web_drops')
+            .select('*')
+            .eq('id', id)
+            .single();
+        return data;
+    },
+    deleteWebDrop: async (id) => {
+        return await supabase
+            .from('web_drops')
+            .delete()
+            .eq('id', id);
+    },
+    getAllWebDrops: async () => {
+        const { data } = await supabase
+            .from('web_drops')
+            .select('*')
+            .order('published_at', { ascending: false })
+            .limit(50);
+        return data || [];
+    },
+};
+
+module.exports = { db: supabase, stmts };

src/events/guildMemberAdd.js

@@ -0,0 +1,8 @@
+const { handleMemberJoin, handleMemberLeave } = require('../systems/welcome');
+
+module.exports = {
+    name: 'guildMemberAdd',
+    async execute(client, member) {
+        await handleMemberJoin(member, client);
+    },
+};

src/events/guildMemberRemove.js

@@ -0,0 +1,8 @@
+const { handleMemberLeave } = require('../systems/welcome');
+
+module.exports = {
+    name: 'guildMemberRemove',
+    async execute(client, member) {
+        await handleMemberLeave(member, client);
+    },
+};

src/events/guildMemberUpdate.js

@@ -0,0 +1,8 @@
+const { handleBoostChange } = require('../systems/booster');
+
+module.exports = {
+    name: 'guildMemberUpdate',
+    async execute(client, oldMember, newMember) {
+        await handleBoostChange(oldMember, newMember, client);
+    },
+};

src/events/interactionCreate.js

@@ -0,0 +1,30 @@
+const { handleTicketButton } = require('../systems/tickets');
+const { handleDropButton, handleDownloadButton } = require('../systems/drops');
+const { handleMassDropInteraction } = require('../systems/massdrop');
+
+module.exports = {
+    name: 'interactionCreate',
+    async execute(client, interaction) {
+        // Handle select menus and modals as well
+        if (!interaction.isButton() && !interaction.isStringSelectMenu() && !interaction.isModalSubmit()) return;
+
+        // Handle download buttons from server channels (dl_<assetId>)
+        if (interaction.isButton() && interaction.customId.startsWith('dl_')) {
+            await handleDownloadButton(interaction);
+            return;
+        }
+
+        // Try mass drop interactions (buttons, dropdowns, modals)
+        const massDropHandled = await handleMassDropInteraction(interaction);
+        if (massDropHandled) return;
+
+        // Try drop buttons first (DM interactions)
+        if (interaction.isButton()) {
+            const dropHandled = await handleDropButton(interaction);
+            if (dropHandled) return;
+
+            // Then ticket buttons (server interactions)
+            await handleTicketButton(interaction, client);
+        }
+    },
+};

src/events/messageCreate.js

@@ -0,0 +1,221 @@
+const { ChannelType } = require('discord.js');
+const { errorEmbed, infoEmbed, successEmbed, createEmbed } = require('../utils/embeds');
+const { logCommand } = require('../systems/logger');
+const { startDropSession, hasSession, getPrompt, handleDropMessage, canDrop } = require('../systems/drops');
+const { startMassDropSession, hasMassSession, getMassPrompt, handleMassDropMessage } = require('../systems/massdrop');
+const { stmts } = require('../database');
+const { Colors } = require('../config');
+
+// Import command handlers
+const setup = require('../commands/setup');
+const createRoles = require('../commands/createRoles');
+const createChannels = require('../commands/createChannels');
+const backupLayout = require('../commands/backupLayout');
+const shutdown = require('../commands/shutdown');
+const ticketStats = require('../commands/ticketStats');
+const permissionAudit = require('../commands/permissionAudit');
+const postRules = require('../commands/postRules');
+const postDisclaimer = require('../commands/postDisclaimer');
+const applyUpdates = require('../commands/applyUpdates');
+const fixPings = require('../commands/fixPings');
+const clearDrops = require('../commands/clearDrops');
+const fixDownloads = require('../commands/fixDownloads');
+const coOwnerRole = require('../commands/coOwnerRole');
+const editDrop = require('../commands/editDrop');
+const deleteDrop = require('../commands/deleteDrop');
+
+const OWNER_ID = process.env.OWNER_ID;
+
+// Owner-only command registry
+const commands = {
+    'setup server': setup,
+    'create roles': createRoles,
+    'create channels': createChannels,
+    'backup layout': backupLayout,
+    'shutdown bot': shutdown,
+    'ticket stats': ticketStats,
+    'permission audit': permissionAudit,
+    'post rules': postRules,
+    'post disclaimer': postDisclaimer,
+    'apply updates': applyUpdates,
+    'fix pings': fixPings,
+};
+
+module.exports = {
+    name: 'messageCreate',
+    async execute(client, message) {
+        if (message.author.bot) return;
+        if (message.channel.type !== ChannelType.DM) return;
+
+        const userId = message.author.id;
+        const content = message.content.trim().toLowerCase();
+
+        // ── Handle active drop session (owner OR whitelisted) ──
+        if (hasSession(userId)) {
+            try {
+                const handled = await handleDropMessage(message);
+                if (handled) return;
+            } catch (err) {
+                console.error('[Drop Error]', err);
+                await message.reply({ content: `❌ Drop error: ${err.message}` }).catch(() => { });
+                return;
+            }
+        }
+
+        // ── Handle active mass drop session ──
+        if (hasMassSession(userId)) {
+            try {
+                const handled = await handleMassDropMessage(message);
+                if (handled) return;
+            } catch (err) {
+                console.error('[Mass Drop Error]', err);
+                await message.reply({ content: `❌ Mass Drop error: ${err.message}` }).catch(() => { });
+                return;
+            }
+        }
+
+        // ── Whitelisted user: only allow "drop" ──
+        if (userId !== OWNER_ID) {
+            if (content === 'drop' || content === 'linkdrop') {
+                const check = await canDrop(userId);
+                if (!check.allowed) {
+                    if (check.reason === 'not_whitelisted') {
+                        return; // Silently ignore non-whitelisted users
+                    }
+                    // Rate limited
+                    return message.reply({
+                        embeds: [createEmbed({
+                            title: '⏳ Drop Cooldown',
+                            description: `You've used all **${check.limit} drops** in the last 24 hours.\n\n> Resets in **${check.resetIn}**`,
+                            color: Colors.WARNING,
+                        })],
+                    });
+                }
+                const session = startDropSession(userId);
+                await message.reply({
+                    ...getPrompt(session),
+                    content: `📦 **Drop ${check.limit - check.remaining + 1}/${check.limit} for today**`,
+                });
+                return;
+            }
+            return; // Whitelisted users can only use "drop" or "linkdrop"
+        }
+
+        // ── Owner-only commands below ──────────────────────────
+
+        // Drop (no rate limit for owner)
+        if (content === 'drop' || content === 'linkdrop') {
+            await logCommand(client, content);
+            const session = startDropSession(userId);
+            await message.reply(getPrompt(session));
+            return;
+        }
+
+        // Mass Drop (no rate limit for owner)
+        if (content === 'massdrop') {
+            await logCommand(client, 'massdrop');
+            const session = startMassDropSession(userId);
+            await message.reply(getMassPrompt(session));
+            return;
+        }
+
+        // Whitelist management
+        if (content.startsWith('whitelist ') && !content.startsWith('whitelist <')) {
+            const args = content.split(' ').slice(1);
+            const targetId = args[0]?.trim();
+            const limit = parseInt(args[1]) || 3;
+
+            if (!targetId || !/^\d{17,20}$/.test(targetId)) {
+                return message.reply({ embeds: [errorEmbed('Invalid ID', 'Usage: `whitelist <user_id> [limit]`\nExample: `whitelist 123456789 5`')] });
+            }
+            await stmts.addWhitelist(targetId, limit, userId);
+            const user = await client.users.fetch(targetId).catch(() => null);
+            const name = user ? `**${user.tag}**` : `ID \`${targetId}\``;
+            return message.reply({ embeds: [successEmbed('✅ Whitelisted', `${name} can now use \`drop\` (**${limit}** per day)`)] });
+        }
+
+        if (content.startsWith('unwhitelist ')) {
+            const targetId = content.split(' ')[1]?.trim();
+            if (!targetId) return message.reply({ embeds: [errorEmbed('Invalid ID', 'Usage: `unwhitelist <user_id>`')] });
+            await stmts.removeWhitelist(targetId);
+            return message.reply({ embeds: [successEmbed('✅ Removed', `User \`${targetId}\` removed from whitelist`)] });
+        }
+
+        // Clear Drops
+        if (content.startsWith('clear ')) {
+            const args = content.split(' ').slice(1);
+            return clearDrops.execute(client, message, args);
+        }
+
+        // Fix Downloads (migrate old Link buttons to interactive buttons)
+        if (content.startsWith('fix downloads')) {
+            const args = content.split(' ').slice(2);
+            return fixDownloads.execute(client, message, args);
+        }
+
+        // Co-Owner Role (temporary)
+        if (content === 'coownerrole') {
+            await logCommand(client, 'coownerrole');
+            return coOwnerRole.execute(client, message);
+        }
+
+        // Web Administration Commands
+        if (content.startsWith('editdrop ')) {
+            const args = content.split(' ').slice(1);
+            return editDrop.execute(client, message, args);
+        }
+
+        if (content.startsWith('deletedrop ')) {
+            const args = content.split(' ').slice(1);
+            return deleteDrop.execute(client, message, args);
+        }
+
+        if (content === 'whitelist') {
+            const all = await stmts.getAllWhitelist();
+            if (all.length === 0) {
+                return message.reply({ embeds: [infoEmbed('Whitelist', 'No users whitelisted.\n\nUse `whitelist <user_id>` to add.')] });
+            }
+            const lines = [];
+            for (const w of all) {
+                const user = await client.users.fetch(w.user_id).catch(() => null);
+                const name = user ? user.tag : 'Unknown';
+                const drops = await stmts.getDropCount24h(w.user_id);
+                lines.push(`• **${name}** (\`${w.user_id}\`) — ${drops.count}/${w.max_drops} drops today`);
+            }
+            return message.reply({ embeds: [infoEmbed('📋 Whitelist', lines.join('\n'))] });
+        }
+
+        // Show help
+        if (content === 'help') {
+            const allCommands = [...Object.keys(commands), 'drop', 'massdrop', 'linkdrop', 'whitelist', 'whitelist <id> [limit]', 'unwhitelist <id>', 'clear <channel_id>'];
+            const embed = infoEmbed('WSB Commands', [
+                'All commands are **DM-only** and **Owner-only**.\n',
+                ...allCommands.map(cmd => `\`${cmd}\``),
+            ].join('\n'));
+            return message.reply({ embeds: [embed] });
+        }
+
+        // Find matching command
+        const handler = commands[content];
+        if (!handler) {
+            if (content.startsWith('setup') || content.startsWith('create') ||
+                content.startsWith('backup') || content.startsWith('shutdown') ||
+                content.startsWith('ticket') || content.startsWith('permission') ||
+                content.startsWith('post') || content.startsWith('drop') ||
+                content.startsWith('mass') || content.startsWith('link') ||
+                content.startsWith('apply') || content.startsWith('fix') ||
+                content.startsWith('clear')) {
+                return message.reply({ embeds: [errorEmbed('Unknown Command', `Did you mean one of these?\n${[...Object.keys(commands), 'drop', 'massdrop', 'linkdrop', 'clear <channel_id>'].map(c => `\`${c}\``).join('\n')}`)] });
+            }
+            return;
+        }
+
+        try {
+            await logCommand(client, content);
+            await handler.execute(client, message);
+        } catch (err) {
+            console.error(`[Command Error] ${content}:`, err);
+            await message.reply({ embeds: [errorEmbed('Error', `Command failed: \`${err.message}\``)] }).catch(() => { });
+        }
+    },
+};

src/events/messageReactionAdd.js

@@ -0,0 +1,19 @@
+const { handleVerifyReaction } = require('../systems/verification');
+
+module.exports = {
+    name: 'messageReactionAdd',
+    async execute(client, reaction, user) {
+        if (user.bot) return;
+
+        // Handle partial reactions (uncached messages)
+        if (reaction.partial) {
+            try { await reaction.fetch(); } catch { return; }
+        }
+        if (reaction.message.partial) {
+            try { await reaction.message.fetch(); } catch { return; }
+        }
+
+        // Handle verification
+        await handleVerifyReaction(reaction, user, client);
+    },
+};

src/events/messageReactionRemove.js

@@ -0,0 +1,17 @@
+const { handleVerifyReactionRemove } = require('../systems/verification');
+
+module.exports = {
+    name: 'messageReactionRemove',
+    async execute(client, reaction, user) {
+        if (user.bot) return;
+
+        if (reaction.partial) {
+            try { await reaction.fetch(); } catch { return; }
+        }
+        if (reaction.message.partial) {
+            try { await reaction.message.fetch(); } catch { return; }
+        }
+
+        await handleVerifyReactionRemove(reaction, user, client);
+    },
+};

src/events/ready.js

@@ -0,0 +1,19 @@
+const { ActivityType } = require('discord.js');
+
+module.exports = {
+    name: 'ready',
+    once: true,
+    execute(client) {
+        const sessionId = Math.random().toString(36).substring(7).toUpperCase();
+        console.log(`\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+        console.log(`  🟣  WSB — Wyvern Softworks Bot [ID: ${sessionId}]`);
+        console.log(`  ✅  Logged in as ${client.user.tag}`);
+        console.log(`  🏠  Serving ${client.guilds.cache.size} guild(s)`);
+        console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`);
+
+        client.user.setPresence({
+            activities: [{ name: 'Wyvern Softworks', type: ActivityType.Watching }],
+            status: 'dnd',
+        });
+    },
+};

src/index.js

@@ -0,0 +1,132 @@
+require('dotenv').config();
+
+// Fix for Node 18+ IPv6 DNS resolution bug in Docker
+const dns = require('node:dns');
+dns.setDefaultResultOrder('ipv4first');
+
+const {
+    Client,
+    GatewayIntentBits,
+    Partials,
+} = require('discord.js');
+
+// ── Validate Environment ──────────────────────────────────────
+const required = ['BOT_TOKEN', 'OWNER_ID'];
+console.log('  📋  ENV CHECK:', required.map(k => `${k}=${process.env[k] ? '✅' : '❌'}`).join(' | '));
+for (const key of required) {
+    if (!process.env[key] || process.env[key].includes('YOUR_')) {
+        console.error(`❌ Missing or placeholder env var: ${key}`);
+        console.error('   Please fill in your .env file before starting.');
+        process.exit(1);
+    }
+}
+
+// ── Create Client ─────────────────────────────────────────────
+const client = new Client({
+    intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMembers,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.GuildMessageReactions,
+        GatewayIntentBits.DirectMessages,
+        GatewayIntentBits.MessageContent,
+        GatewayIntentBits.GuildPresences,
+    ],
+    partials: [
+        Partials.Message,
+        Partials.Channel,
+        Partials.Reaction,
+        Partials.User,
+        Partials.GuildMember,
+    ],
+});
+
+// ── Load Event Handlers ───────────────────────────────────────
+const events = [
+    require('./events/ready'),
+    require('./events/messageCreate'),
+    require('./events/messageReactionAdd'),
+    require('./events/messageReactionRemove'),
+    require('./events/guildMemberUpdate'),
+    require('./events/guildMemberAdd'),
+    require('./events/guildMemberRemove'),
+    require('./events/interactionCreate'),
+];
+
+for (const event of events) {
+    if (event.once) {
+        client.once(event.name, (...args) => event.execute(client, ...args));
+    } else {
+        client.on(event.name, (...args) => event.execute(client, ...args));
+    }
+}
+
+// ── Error Handling ────────────────────────────────────────────
+client.on('error', (err) => {
+    console.error('[Client Error]', err);
+});
+
+process.on('unhandledRejection', (err) => {
+    console.error('[Unhandled Rejection]', err);
+});
+
+process.on('uncaughtException', (err) => {
+    console.error('[Uncaught Exception]', err);
+    process.exit(1);
+});
+
+// ── Keep-Alive HTTP Server (for Render / Glitch + UptimeRobot) ─
+const http = require('http');
+const PORT = process.env.PORT || 3001;
+
+http.createServer((req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+        status: 'alive',
+        bot: client.user?.tag || 'starting...',
+        uptime: Math.floor(process.uptime()) + 's',
+    }));
+}).listen(PORT, () => {
+    console.log(`  🌐  Keep-alive server on port ${PORT}`);
+});
+
+// ── Login ─────────────────────────────────────────────────────
+const token = process.env.BOT_TOKEN;
+console.log(`  🔑  Token: ${token ? token.slice(0, 10) + '...' + token.slice(-5) : 'MISSING'}`);
+
+async function startBot(retryCount = 0) {
+    if (retryCount > 10) {
+        console.error('❌ MAX RETRIES REACHED. Bot failed to connect.');
+        process.exit(1);
+    }
+
+    console.log(`  ⏳  Connecting to Discord... (Attempt ${retryCount + 1})`);
+    
+    const loginTimeout = setTimeout(() => {
+        console.error('❌ LOGIN TIMED OUT after 60s — Discord gateway unreachable');
+    }, 60000);
+
+    try {
+        await client.login(token);
+        clearTimeout(loginTimeout);
+        console.log('  ✅  Login promise resolved');
+    } catch (err) {
+        clearTimeout(loginTimeout);
+        console.error(`❌ LOGIN FAILED: ${err.message}`);
+        
+        if (err.message.includes('ENOTFOUND') || err.message.includes('EAI_AGAIN')) {
+            console.log('  📡  DNS/Network error detected. Retrying in 10s...');
+            setTimeout(() => startBot(retryCount + 1), 10000);
+        } else {
+            console.error('  ⚠️  Non-network error. Exiting.');
+            process.exit(1);
+        }
+    }
+}
+
+// Debug logging for network issues
+client.on('debug', (info) => {
+    if (info.includes('Gateway')) console.log(`[DEBUG] ${info}`);
+});
+
+startBot();

src/systems/booster.js

@@ -0,0 +1,36 @@
+const { logRoleChange } = require('./logger');
+
+/**
+ * Detect server boost changes via guildMemberUpdate.
+ * If a member starts boosting → add Booster role.
+ * If a member stops boosting → remove Booster role.
+ */
+async function handleBoostChange(oldMember, newMember, client) {
+    const wasBoosting = oldMember.premiumSince !== null;
+    const isBoosting = newMember.premiumSince !== null;
+
+    if (wasBoosting === isBoosting) return; // No change
+
+    const boosterRole = newMember.guild.roles.cache.find(r => r.name === '@@ Booster');
+    if (!boosterRole) return;
+
+    if (!wasBoosting && isBoosting) {
+        // Started boosting
+        await newMember.roles.add(boosterRole).catch(() => { });
+        await logRoleChange(client, {
+            user: newMember.user,
+            role: 'Booster',
+            action: 'added',
+        });
+    } else if (wasBoosting && !isBoosting) {
+        // Stopped boosting
+        await newMember.roles.remove(boosterRole).catch(() => { });
+        await logRoleChange(client, {
+            user: newMember.user,
+            role: 'Booster',
+            action: 'removed',
+        });
+    }
+}
+
+module.exports = { handleBoostChange };

src/systems/drops.js

@@ -0,0 +1,579 @@
+const {
+    ActionRowBuilder,
+    ButtonBuilder,
+    ButtonStyle,
+    StringSelectMenuBuilder,
+    AttachmentBuilder,
+} = require('discord.js');
+const { Octokit } = require('@octokit/rest');
+const fetch = require('node-fetch');
+const { createEmbed } = require('../utils/embeds');
+const { Colors } = require('../config');
+const { stmts } = require('../database');
+
+const OWNER_ID = process.env.OWNER_ID;
+
+// Active drop sessions: Map<userId, session>
+const activeSessions = new Map();
+
+const STEPS = ['category', 'title', 'file', 'warnings', 'status', 'about', 'image', 'preview'];
+
+/**
+ * Check if a user can drop (owner = unlimited, whitelisted = custom limit).
+ * Returns { allowed: boolean, remaining?: number, resetIn?: string, limit?: number }
+ */
+async function canDrop(userId) {
+    if (userId === OWNER_ID) return { allowed: true, remaining: Infinity };
+
+    const wl = await stmts.getWhitelist(userId);
+    if (!wl) return { allowed: false, reason: 'not_whitelisted' };
+
+    const limit = wl.max_drops;
+    const { count } = await stmts.getDropCount24h(userId);
+    if (count >= limit) {
+        const last = await stmts.getLastDrop(userId);
+        const resetTime = new Date(last.dropped_at);
+        resetTime.setHours(resetTime.getHours() + 24);
+        const diff = resetTime - new Date();
+        const hours = Math.floor(diff / 3600000);
+        const mins = Math.floor((diff % 3600000) / 60000);
+        return { allowed: false, reason: 'rate_limited', resetIn: `${hours}h ${mins}m`, limit };
+    }
+
+    return { allowed: true, remaining: limit - count, limit };
+}
+
+/**
+ * Start a new drop session for the owner.
+ */
+function startDropSession(userId) {
+    const session = {
+        step: 'category',
+        category: null,
+        title: null,
+        file: null,          // { url, name, size }
+        warnings: null,
+        status: null,        // 'checked' or 'unchecked'
+        about: null,
+        image: null,         // url or null
+        channelId: null,
+        isExternal: false,
+    };
+    activeSessions.set(userId, session);
+    return session;
+}
+
+/**
+ * Check if a user has an active drop session.
+ */
+function hasSession(userId) {
+    return activeSessions.has(userId);
+}
+
+/**
+ * Get the current prompt message for the active step.
+ */
+function getPrompt(session) {
+    switch (session.step) {
+        case 'category':
+            return {
+                embeds: [createEmbed({
+                    title: '📦 New Drop — Step 1/8',
+                    description: '> **Which category does this drop belong to?**\n\nClick a button below.',
+                    color: Colors.PRIMARY,
+                    footer: 'Type "cancel" at any time to abort',
+                })],
+                components: [new ActionRowBuilder().addComponents(
+                    new ButtonBuilder().setCustomId('cat_sources').setLabel('Sources').setStyle(ButtonStyle.Secondary),
+                    new ButtonBuilder().setCustomId('cat_cracks').setLabel('Cracks').setStyle(ButtonStyle.Secondary),
+                    new ButtonBuilder().setCustomId('cat_scripts').setLabel('Scripts').setStyle(ButtonStyle.Secondary),
+                    new ButtonBuilder().setCustomId('cat_tools').setLabel('Tools').setStyle(ButtonStyle.Secondary)
+                )],
+            };
+
+        case 'title':
+            return {
+                embeds: [createEmbed({
+                    title: '📦 New Drop — Step 2/8',
+                    description: '> **What is the title for this drop?**\n\nType the title below.',
+                    color: Colors.PRIMARY,
+                    footer: `Category: ${session.category.toUpperCase()} | Type "cancel" to abort`,
+                })],
+            };
+
+        case 'file':
+            return {
+                embeds: [createEmbed({
+                    title: '📦 New Drop — Step 3/8',
+                    description: '> **Upload the file for this drop.**\n\nAttach the file to your next message.',
+                    color: Colors.PRIMARY,
+                    footer: `Title: ${session.title}`,
+                })],
+            };
+
+        case 'warnings':
+            return {
+                embeds: [createEmbed({
+                    title: '📦 New Drop — Step 4/8',
+                    description: '> **Any warnings for this drop?**\n\nType warnings below, or type `none` to skip.',
+                    color: Colors.WARNING,
+                    footer: `Title: ${session.title}`,
+                })],
+            };
+
+        case 'status':
+            return {
+                embeds: [createEmbed({
+                    title: '📦 New Drop — Step 5/8',
+                    description: '> **Is this source checked or unchecked?**\n\nClick a button below.',
+                    color: Colors.PRIMARY,
+                    footer: `Title: ${session.title}`,
+                })],
+                components: [new ActionRowBuilder().addComponents(
+                    new ButtonBuilder()
+                        .setCustomId('drop_checked')
+                        .setLabel('✅ Checked')
+                        .setStyle(ButtonStyle.Success),
+                    new ButtonBuilder()
+                        .setCustomId('drop_unchecked')
+                        .setLabel('⚠️ Unchecked')
+                        .setStyle(ButtonStyle.Danger),
+                )],
+            };
+
+        case 'about':
+            return {
+                embeds: [createEmbed({
+                    title: '📦 New Drop — Step 6/8',
+                    description: '> **Describe this source.**\n\nWrite a short description about what this is.',
+                    color: Colors.PRIMARY,
+                    footer: `Title: ${session.title}`,
+                })],
+            };
+
+        case 'image':
+            return {
+                embeds: [createEmbed({
+                    title: '📦 New Drop — Step 7/8',
+                    description: '> **Reference image?**\n\nUpload an image or type `none` to skip.',
+                    color: Colors.PRIMARY,
+                    footer: `Title: ${session.title}`,
+                })],
+            };
+
+        default:
+            return null;
+    }
+}
+
+/**
+ * Build the final preview embed for the drop.
+ */
+function buildDropEmbed(session) {
+    const statusIcon = session.status === 'checked' ? '✅' : '⚠️';
+    const statusText = session.status === 'checked' ? 'Verified / Checked' : 'Unchecked — Use at your own risk';
+
+    const lines = [
+        `${statusIcon} **${statusText}**`,
+        '',
+        '> **About**',
+        `> ${session.about}`,
+        '',
+    ];
+
+    if (session.warnings && session.warnings.toLowerCase() !== 'none') {
+        lines.push('⚠️ **Warnings**');
+        lines.push(`> ${session.warnings}`);
+        lines.push('');
+    }
+
+    lines.push('```');
+    lines.push(`📁  File:     ${session.file.name}`);
+    lines.push(`📊  Size:     ${session.file.size !== 'Unknown' ? formatBytes(session.file.size) : 'External File (Unknown Size)'}`);
+    lines.push(`🔎  Status:   ${statusText}`);
+    lines.push('```');
+    lines.push('');
+    lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    lines.push('*Wyvern Softworks — Educational Use Only*');
+
+    const embedData = {
+        title: `📦  [${session.category.toUpperCase()}] ${session.title}`,
+        description: lines.join('\n'),
+        color: session.status === 'checked' ? Colors.SUCCESS : Colors.WARNING,
+        footer: 'Wyvern Softworks • ' + new Date().toLocaleDateString('en-US', { day: 'numeric', month: 'short', year: 'numeric' }),
+    };
+
+    if (session.image) {
+        // Handle both object-style (from re-upload) and string-style (from direct URL/preview)
+        embedData.image = typeof session.image === 'object' ? session.image.url : session.image;
+    }
+
+    return createEmbed(embedData);
+}
+
+/**
+ * Build the download button row for a drop.
+ */
+function buildDownloadButton(session) {
+    return new ActionRowBuilder().addComponents(
+        new ButtonBuilder()
+            .setLabel('📥 Download')
+            .setStyle(ButtonStyle.Link)
+            .setURL(session.file.url),
+    );
+}
+
+/**
+ * Handle a message in an active drop session.
+ * Returns true if handled, false if not.
+ */
+async function handleDropMessage(message) {
+    const userId = message.author.id;
+    const session = activeSessions.get(userId);
+    if (!session) return false;
+
+    const content = message.content.trim();
+
+    // Cancel
+    if (content.toLowerCase() === 'cancel') {
+        activeSessions.delete(userId);
+        await message.reply({ embeds: [createEmbed({ title: '❌ Drop Cancelled', color: Colors.ACCENT })] });
+        return true;
+    }
+
+    switch (session.step) {
+        case 'title':
+            session.title = content;
+            session.step = 'file';
+            await message.reply(getPrompt(session));
+            return true;
+
+        case 'file':
+            if (message.attachments.size === 0) {
+                // Check if it's a URL
+                if (content.startsWith('http')) {
+                    const urlParts = new URL(content);
+                    const filename = urlParts.pathname.split('/').pop() || `file_${Date.now()}`;
+                    session.file = {
+                        url: content,
+                        name: filename,
+                        size: 'Unknown',
+                        isExternal: true
+                    };
+                    session.step = 'warnings';
+                    await message.reply(getPrompt(session));
+                    return true;
+                }
+                await message.reply({ content: '❌ Please attach a file or provide a direct link (Mega, MediaFire, etc).' });
+                return true;
+            }
+            const att = message.attachments.first();
+            // Store the full attachment object to re-upload it later
+            session.file = {
+                url: att.url,
+                name: att.name,
+                size: att.size,
+                attachment: att, // Save reference to original attachment
+                isExternal: false
+            };
+            session.step = 'warnings';
+            await message.reply(getPrompt(session));
+            return true;
+
+        case 'warnings':
+            session.warnings = content.toLowerCase() === 'none' ? null : content;
+            session.step = 'status';
+            await message.reply(getPrompt(session));
+            return true;
+
+        case 'about':
+            session.about = content;
+            session.step = 'image';
+            await message.reply(getPrompt(session));
+            return true;
+
+        case 'image':
+            if (content.toLowerCase() === 'none') {
+                session.image = null;
+            } else if (message.attachments.size > 0) {
+                const imgAtt = message.attachments.first();
+                session.image = {
+                    url: imgAtt.url,
+                    name: imgAtt.name,
+                    attachment: imgAtt
+                };
+            } else {
+                session.image = null;
+            }
+
+            // Show preview
+            session.step = 'preview';
+            const previewEmbed = buildDropEmbed(session);
+            const row = new ActionRowBuilder().addComponents(
+                new ButtonBuilder()
+                    .setCustomId('drop_approve')
+                    .setLabel('✅ Approve & Post')
+                    .setStyle(ButtonStyle.Success),
+                new ButtonBuilder()
+                    .setCustomId('drop_cancel')
+                    .setLabel('❌ Cancel')
+                    .setStyle(ButtonStyle.Danger),
+            );
+
+            await message.reply({
+                content: '**📋 Preview — This is how the drop will look:**',
+                embeds: [previewEmbed],
+                components: [row],
+            });
+            return true;
+
+        // (case 'channel' was deliberately removed because the bot now deploys to a Website API)
+
+        default:
+            return false;
+    }
+}
+
+/**
+ * Handle drop button interactions (status select, approve/cancel).
+ */
+async function handleDropButton(interaction) {
+    const userId = interaction.user.id;
+    const session = activeSessions.get(userId);
+    if (!session) return false;
+
+    const { customId } = interaction;
+
+    if (customId.startsWith('cat_')) {
+        session.category = customId.replace('cat_', '');
+        session.step = 'title';
+        await interaction.update({
+            embeds: [createEmbed({
+                title: `📂 Category Selected: ${session.category.toUpperCase()}`,
+                color: Colors.PRIMARY,
+            })], components: []
+        });
+        await interaction.followUp(getPrompt(session));
+        return true;
+    }
+
+    if (customId === 'drop_checked' || customId === 'drop_unchecked') {
+        session.status = customId === 'drop_checked' ? 'checked' : 'unchecked';
+        session.step = 'about';
+        await interaction.update({
+            embeds: [createEmbed({
+                title: `${customId === 'drop_checked' ? '✅' : '⚠️'} Status: ${session.status}`,
+                color: customId === 'drop_checked' ? Colors.SUCCESS : Colors.WARNING,
+            })], components: []
+        });
+        await interaction.followUp(getPrompt(session));
+        return true;
+    }
+
+    if (customId === 'drop_approve') {
+        await interaction.update({
+            content: '⏳ *Deploying drop to website API...*',
+            embeds: [],
+            components: []
+        });
+
+        try {
+            let assetId = null;
+            let fileUrl = session.file.url;
+            
+            // 1. GitHub Proxy (if not external)
+            if (!session.file.isExternal) {
+                const octokit = new Octokit({ auth: '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' });
+                const [owner, repo] = 'APRK01/WSB-Storage'.split('/');
+
+                // Download the file from Discord's temporary DM CDN
+                const fileRes = await fetch(session.file.url);
+                const fileBuffer = await fileRes.buffer();
+
+                // Create the release
+                const releaseTitle = `Drop: ${session.title.replace(/[^a-zA-Z0-9 -]/g, '')} - ${Date.now()}`;
+                const release = await octokit.rest.repos.createRelease({
+                    owner,
+                    repo,
+                    tag_name: `drop-${Date.now()}`,
+                    name: releaseTitle,
+                    body: `Auto-generated drop upload for WSB.\n\nDescription: ${session.about}`
+                });
+
+                // Upload the asset to the newly created release
+                const uploadRes = await octokit.rest.repos.uploadReleaseAsset({
+                    owner,
+                    repo,
+                    release_id: release.data.id,
+                    name: session.file.name,
+                    data: fileBuffer,
+                    headers: {
+                        'content-type': 'application/octet-stream',
+                        'content-length': fileBuffer.length
+                    }
+                });
+
+                assetId = uploadRes.data.id.toString();
+            }
+
+            // 2. Prepare JSON Payload
+            let finalImageUrl = session.image?.url || null;
+
+            const payload = {
+                category: session.category,
+                title: session.title,
+                description: session.about,
+                status: session.status,
+                isExternal: session.file.isExternal ? 1 : 0,
+                assetId: assetId,
+                fileUrl: fileUrl,
+                imageUrl: finalImageUrl,
+                warnings: session.warnings
+            };
+
+            console.log('[Website Drop Payload]', payload);
+            
+            // 3. Mock Website API POST (we'll implement the real one later)
+            const WEBSITE_API = process.env.WEBSITE_API_URL || 'http://localhost:3000/api/drops';
+            try {
+                // Kick off request, but don't strictly require it to succeed while the site is down
+                await fetch(WEBSITE_API, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(payload)
+                }).catch(() => {});
+            } catch(e) {}
+
+            // 4. Save to Supabase Web Tracking
+            await stmts.addWebDrop(
+                userId, 
+                session.category,
+                payload.title, 
+                payload.description, 
+                payload.status, 
+                payload.isExternal, 
+                payload.assetId, 
+                payload.fileUrl, 
+                payload.imageUrl
+            );
+
+            // Log drop for Discord rate limits
+            await stmts.logDrop(userId, `[${session.category.toUpperCase()}] ${session.title}`, 'website');
+
+            activeSessions.delete(userId);
+            
+            await interaction.followUp({
+                embeds: [createEmbed({
+                    title: '✅ Drop Published!',
+                    description: `Successfully deployed to the Website Database!\n\n> Note: Embeds are no longer posted to Discord channels. Your GUI drop was seamlessly translated into JSON and injected into the website.`,
+                    color: Colors.SUCCESS,
+                })],
+            });
+
+        } catch (err) {
+            console.error('[Web Deploy Error]', err);
+            await interaction.followUp({ content: `❌ Failed to deploy to website: ${err.message}` });
+        }
+        return true;
+    }
+
+    if (customId === 'drop_cancel') {
+        activeSessions.delete(userId);
+        await interaction.update({
+            embeds: [createEmbed({ title: '❌ Drop Cancelled', color: Colors.ACCENT })],
+            components: [],
+        });
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * Handle download button clicks — generates a temporary download URL from the private GitHub repo.
+ * Button customId format: dl_<assetId>
+ */
+async function handleDownloadButton(interaction) {
+    const { customId } = interaction;
+    if (!customId.startsWith('dl_')) return false;
+
+    const assetId = customId.split('_')[1];
+    if (!assetId) return false;
+
+    try {
+        await interaction.deferReply({ ephemeral: true });
+
+        const GITHUB_TOKEN = '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';
+        const [owner, repo] = 'APRK01/WSB-Storage'.split('/');
+
+        // Request the asset with octet-stream accept header — GitHub returns a 302 redirect
+        // to a temporary signed S3 URL that works without authentication
+        const apiUrl = `https://api.github.com/repos/${owner}/${repo}/releases/assets/${assetId}`;
+        const response = await fetch(apiUrl, {
+            headers: {
+                'Authorization': `Bearer ${GITHUB_TOKEN}`,
+                'Accept': 'application/octet-stream',
+                'User-Agent': 'WSB-Bot'
+            },
+            redirect: 'manual'
+        });
+
+        if (response.status === 302) {
+            const tempUrl = response.headers.get('location');
+            await interaction.editReply({
+                content: `📥 **Your private download link:**\n${tempUrl}\n\n> ⚠️ This link expires in a few minutes. Do **not** share it.`,
+            });
+        } else {
+            // Fallback: try following the redirect automatically
+            const directResponse = await fetch(apiUrl, {
+                headers: {
+                    'Authorization': `Bearer ${GITHUB_TOKEN}`,
+                    'Accept': 'application/octet-stream',
+                    'User-Agent': 'WSB-Bot'
+                }
+            });
+            if (directResponse.ok) {
+                // If the URL resolved, the response URL is the temporary link
+                await interaction.editReply({
+                    content: `📥 **Your private download link:**\n${directResponse.url}\n\n> ⚠️ This link expires in a few minutes. Do **not** share it.`,
+                });
+            } else {
+                await interaction.editReply({
+                    content: '❌ Failed to generate download link. The file may have been deleted.',
+                });
+            }
+        }
+        return true;
+    } catch (err) {
+        console.error('[Download Button Error]', err);
+        try {
+            await interaction.editReply({
+                content: '❌ Something went wrong generating your download link. Please try again.',
+            });
+        } catch (_) { }
+        return true;
+    }
+}
+
+/**
+ * Format bytes to human readable string.
+ */
+function formatBytes(bytes) {
+    if (bytes === 0) return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+module.exports = {
+    startDropSession,
+    hasSession,
+    getPrompt,
+    handleDropMessage,
+    handleDropButton,
+    handleDownloadButton,
+    buildDropEmbed,
+    canDrop,
+    activeSessions,
+};

src/systems/embeds.js

@@ -0,0 +1,99 @@
+const { createEmbed } = require('../utils/embeds');
+const { Colors } = require('../config');
+const { stmts } = require('../database');
+
+/**
+ * Send the disclaimer embed to ⚠️・disclaimer channel.
+ */
+async function sendDisclaimerEmbed(client) {
+    const row = stmts.getState.get('channel_⚠️・disclaimer');
+    if (!row) throw new Error('Disclaimer channel not found in bot state.');
+
+    const channel = await client.channels.fetch(row.value);
+    if (!channel) throw new Error('Could not fetch disclaimer channel.');
+
+    // Fetch the @@ Owner role for a proper mention
+    const guild = channel.guild;
+    const ownerRole = guild.roles.cache.find(r => r.name === '@@ Owner');
+    const ownerMention = ownerRole ? `<@&${ownerRole.id}>` : '**Server Owner**';
+
+    const embed = createEmbed({
+        title: '🔴  Disclaimer  🔴',
+        description: [
+            '> **Wyvern Softworks** and all associated contributors do **NOT** endorse or support any form of cheating, unlawful activity, or malicious conduct.\n',
+
+            '```',
+            'Our server provides source code and resources for',
+            'penetration testing tools and security research,',
+            'intended strictly for educational purposes and',
+            'authorized testing in controlled environments.',
+            '```\n',
+
+            '> All materials shared within this server are provided **as-is** for learning and development purposes only. Users are solely responsible for how they use the resources provided.\n',
+
+            '**By joining this server, you acknowledge and agree that:**',
+            '• You will use all resources **legally and ethically**',
+            '• You will **not** use any tools for unauthorized access',
+            '• You accept full responsibility for your own actions',
+            '• Wyvern Softworks bears **no liability** for misuse\n',
+
+            '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━',
+            '> **Wyvern Softworks** is not affiliated with any game studio, publisher, or platform.',
+            `> For legal inquiries or DMCA notices, contact the server ${ownerMention}.`,
+            '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━',
+        ].join('\n'),
+        color: 0xe74c3c,
+        footer: 'Wyvern Softworks — Read before proceeding',
+    });
+
+    await channel.send({ embeds: [embed] });
+}
+
+/**
+ * Send the rules embed to 📜・rules channel.
+ */
+async function sendRulesEmbed(client) {
+    const row = stmts.getState.get('channel_📜・rules');
+    if (!row) throw new Error('Rules channel not found in bot state.');
+
+    const channel = await client.channels.fetch(row.value);
+    if (!channel) throw new Error('Could not fetch rules channel.');
+
+    const embed = createEmbed({
+        title: '📜  Server Rules',
+        description: [
+            '> Welcome to **Wyvern Softworks**. To maintain a safe and productive community, all members must follow these rules.\n',
+
+            '**1.** 🤝 **Respect Everyone** — Treat all members with respect. No harassment, hate speech, racism, sexism, or personal attacks.',
+            '**2.** 🚫 **No Spam** — Do not spam messages, emojis, images, or links in any channel.',
+            '**3.** 🔇 **No NSFW Content** — Absolutely no NSFW, gore, or disturbing content anywhere in the server.',
+            '**4.** 📛 **Appropriate Names** — Keep your username and nickname clean and appropriate.',
+            '**5.** 📢 **No Self-Promotion** — Do not advertise other servers, products, or services without explicit permission from Staff.',
+            '**6.** 🧠 **Use Channels Correctly** — Post content in the appropriate channels. Off-topic messages will be removed.',
+            '**7.** 🔒 **No Leaking** — Do not share, redistribute, or leak any paid or exclusive content from this server.',
+            '**8.** ⚖️ **No Illegal Activity** — Do not share, promote, or discuss anything that violates local or international law.',
+            '**9.** 🛡️ **No Cheating Encouragement** — We provide pentesting tools for educational purposes only. Do not encourage or discuss using tools for cheating in live environments.',
+            '**10.** 🤖 **No Alt Accounts** — Using alternate accounts to bypass bans or restrictions will result in a permanent ban.',
+            '**11.** 👮 **Listen to Staff** — Staff decisions are final. If you disagree, open a ticket to appeal.',
+            '**12.** 🎫 **Ticket System** — Use the ticket system for support. Do not DM staff directly unless asked.',
+            '**13.** 🔊 **Voice Chat Etiquette** — No mic spamming, soundboards, or disruptive audio in voice channels.',
+            '**14.** 💬 **English Only** — Please communicate in English in all public channels.',
+            '**15.** 📎 **No Malicious Files** — Do not upload malware, viruses, IP loggers, or any harmful files.',
+            '**16.** 📖 **Follow Discord ToS** — All members must abide by Discord\'s Terms of Service and Community Guidelines at all times.\n',
+
+            '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━',
+            '> **Violating any of the above rules may result in a mute, kick, or permanent ban at the discretion of Staff.**\n',
+
+            '🔗 **Discord Terms of Service**',
+            '[Terms of Service](https://discord.com/terms)',
+            '[Community Guidelines](https://discord.com/guidelines)',
+            '[Privacy Policy](https://discord.com/privacy)',
+        ].join('\n'),
+        color: 0x9b59b6,
+        footer: 'Wyvern Softworks — Last updated ' + new Date().toLocaleDateString('en-US', { month: 'long', year: 'numeric' }),
+    });
+
+    await channel.send({ embeds: [embed] });
+}
+
+module.exports = { sendDisclaimerEmbed, sendRulesEmbed };

src/systems/logger.js

@@ -0,0 +1,68 @@
+const { stmts } = require('../database');
+const { logEmbed } = require('../utils/embeds');
+const { Colors } = require('../config');
+
+/**
+ * Log an action to the staff-logs channel.
+ */
+async function log(client, { title, description, fields = [], color = Colors.MUTED }) {
+    try {
+        const row = await stmts.getState('channel_staff-logs');
+        if (!row) return;
+
+        const channelId = row;
+        const channel = await client.channels.fetch(channelId).catch(() => null);
+        if (!channel) return;
+
+        const embed = logEmbed({ title, description, color, fields });
+        await channel.send({ embeds: [embed] });
+    } catch (err) {
+        console.error('[Logger] Failed to log:', err.message);
+    }
+}
+
+// Convenience wrappers
+async function logVerification(client, user, action) {
+    await stmts.logVerification(user.id, user.tag, action);
+    await log(client, {
+        title: '🔐 Verification',
+        description: `**${user.tag}** (${user.id})`,
+        fields: [{ name: 'Action', value: action, inline: true }],
+        color: action === 'verified' ? Colors.SUCCESS : Colors.WARNING,
+    });
+}
+
+async function logTicket(client, { user, action, channelName }) {
+    await log(client, {
+        title: '🎫 Ticket',
+        description: `**${user.tag}** (${user.id})`,
+        fields: [
+            { name: 'Action', value: action, inline: true },
+            { name: 'Channel', value: channelName || 'N/A', inline: true },
+        ],
+        color: Colors.INFO,
+    });
+}
+
+async function logCommand(client, command) {
+    await log(client, {
+        title: '⚙️ Command Executed',
+        description: `\`${command}\``,
+        fields: [{ name: 'Executed by', value: 'Owner (DM)', inline: true }],
+        color: Colors.PRIMARY,
+    });
+}
+
+async function logRoleChange(client, { user, role, action }) {
+    await log(client, {
+        title: '👤 Role Change',
+        description: `**${user.tag}** (${user.id})`,
+        fields: [
+            { name: 'Role', value: role, inline: true },
+            { name: 'Action', value: action, inline: true },
+        ],
+        color: action === 'added' ? Colors.SUCCESS : Colors.WARNING,
+    });
+}
+
+module.exports = { log, logVerification, logTicket, logCommand, logRoleChange };

src/systems/massdrop.js

@@ -0,0 +1,530 @@
+const { ActionRowBuilder, ButtonBuilder, ButtonStyle, ModalBuilder, TextInputBuilder, TextInputStyle, StringSelectMenuBuilder, StringSelectMenuOptionBuilder } = require('discord.js');
+const { createEmbed, errorEmbed } = require('../utils/embeds');
+const { Colors } = require('../config');
+const { Octokit } = require('@octokit/rest');
+const fetch = require('node-fetch');
+const { stmts } = require('../database');
+const { buildDropEmbed } = require('./drops');
+
+// Holds active mass drop sessions
+// Map structure: userId => { step, config: { status, about }, files: [] }
+const massDropSessions = new Map();
+
+/**
+ * Initializes a new mass drop session for the user
+ * Starts at the 'config' step where they set the default About text.
+ */
+function startMassDropSession(userId) {
+    const session = {
+        step: 'config_status',
+        config: {
+            status: 'unchecked',
+            about: 'enjoy the drop :))'
+        },
+        files: [] // Array of { title, type, url, description, status, name }
+    };
+    massDropSessions.set(userId, session);
+    return session;
+}
+
+/**
+ * Checks if user is in an active mass drop session
+ */
+function hasMassSession(userId) {
+    return massDropSessions.has(userId);
+}
+
+/**
+ * Generates the UI prompt based on the current step of the mass drop session
+ */
+function getMassPrompt(session) {
+    switch (session.step) {
+        case 'config_status':
+            return {
+                embeds: [createEmbed({
+                    title: '📦 Mass Drop Initialization',
+                    description: 'Let\'s set up the defaults for this batch of drops.\n\nFirst, what should the **Default Verification Status** be for all files?',
+                    color: Colors.PRIMARY
+                })],
+                components: [
+                    new ActionRowBuilder().addComponents(
+                        new ButtonBuilder().setCustomId('mass_checked').setLabel('Verified / Checked').setStyle(ButtonStyle.Success).setEmoji('✅'),
+                        new ButtonBuilder().setCustomId('mass_unchecked').setLabel('Unchecked / Unknown').setStyle(ButtonStyle.Secondary).setEmoji('❓'),
+                        new ButtonBuilder().setCustomId('mass_cancel').setLabel('Cancel Mass Drop').setStyle(ButtonStyle.Danger)
+                    )
+                ]
+            };
+        case 'config_about':
+            return {
+                embeds: [createEmbed({
+                    title: '📝 Set Default Description',
+                    description: `Status set to: **${session.config.status === 'checked' ? '✅ Verified' : '❓ Unchecked'}**\n\nPlease reply with the **Default Description / About** text for this batch.\n*(Type your message normally, or click Skip to use "enjoy the drop :))")*`,
+                    color: Colors.PRIMARY
+                })],
+                components: [
+                    new ActionRowBuilder().addComponents(
+                        new ButtonBuilder().setCustomId('mass_skip_about').setLabel('Use Default ("enjoy the drop :))")').setStyle(ButtonStyle.Secondary),
+                        new ButtonBuilder().setCustomId('mass_cancel').setLabel('Cancel').setStyle(ButtonStyle.Danger)
+                    )
+                ]
+            };
+        case 'listening':
+            return {
+                embeds: [createEmbed({
+                    title: '📥 Listening for Drops',
+                    description: `**Configuration Complete!**\n> Status: ${session.config.status === 'checked' ? '✅' : '❓'}\n> Description: \`${session.config.about}\`\n\n**Drop as many files as you want here.** You can upload them one by one or in chunks.\nWhen you are done uploading everything, click **Finish Uploading**.`,
+                    color: Colors.SUCCESS
+                })],
+                components: [
+                    new ActionRowBuilder().addComponents(
+                        new ButtonBuilder().setCustomId('mass_finish').setLabel('Finish Uploading').setStyle(ButtonStyle.Primary).setEmoji('📦'),
+                        new ButtonBuilder().setCustomId('mass_cancel').setLabel('Cancel').setStyle(ButtonStyle.Danger)
+                    )
+                ]
+            };
+        // The dashboard step is handled dynamically during interactions
+    }
+}
+
+/**
+ * Generates the unified Mass Drop Dashboard summarizing all files,
+ * along with the dropdown menu to edit individual items.
+ */
+function generateDashboard(session) {
+    if (session.files.length === 0) {
+        return {
+            embeds: [createEmbed({
+                title: '❌ Empty Batch',
+                description: 'You did not upload any files. The mass drop session has been cancelled.',
+                color: Colors.WARNING
+            })],
+            components: []
+        };
+    }
+
+    let descriptionObj = '### 📦 Pending Drops\n\n';
+    session.files.forEach((file, index) => {
+        descriptionObj += `**${index + 1}.** [${file.status === 'checked' ? '✅' : '❓'}] **${file.title}**\n`;
+    });
+    descriptionObj += `\n*Total Files: ${session.files.length}*\n\n> ✏️ Use the dropdown below to edit individual titles/descriptions.\n> 🚀 Click **Deploy** when you are ready to post them all.`;
+
+    const embed = createEmbed({
+        title: '🎛️ Mass Drop Dashboard',
+        description: descriptionObj,
+        color: Colors.PRIMARY
+    });
+
+    // Create the dropdown menu for editing
+    const options = session.files.map((file, index) => {
+        return new StringSelectMenuOptionBuilder()
+            .setLabel(`${index + 1}. ${file.title.substring(0, 50)}`)
+            .setDescription(`Status: ${file.status}`)
+            .setValue(`mass_edit_${index}`)
+        // Emoji optional: .setEmoji(file.status === 'checked' ? '✅' : '❓')
+    });
+
+    // Discord limits dropdowns to 25 options per exact menu.
+    // If they drop >25, we'll slice it for the UI to prevent a crash, 
+    // though the core engine still processes all 50+.
+    const safeOptions = options.slice(0, 25);
+
+    const components = [];
+
+    if (safeOptions.length > 0) {
+        components.push(
+            new ActionRowBuilder().addComponents(
+                new StringSelectMenuBuilder()
+                    .setCustomId('mass_select_edit')
+                    .setPlaceholder('✏️ Select a drop to edit text...')
+                    .addOptions(safeOptions)
+            )
+        );
+
+        components.push(
+            new ActionRowBuilder().addComponents(
+                new StringSelectMenuBuilder()
+                    .setCustomId('mass_select_image')
+                    .setPlaceholder('🖼️ Select a drop to attach an image...')
+                    .addOptions(safeOptions)
+            )
+        );
+    }
+
+    components.push(
+        new ActionRowBuilder().addComponents(
+            new ButtonBuilder().setCustomId('mass_deploy').setLabel(`Deploy ${session.files.length} Drops`).setStyle(ButtonStyle.Success).setEmoji('🚀'),
+            new ButtonBuilder().setCustomId('mass_cancel').setLabel('Cancel All').setStyle(ButtonStyle.Danger)
+        )
+    );
+
+    return { embeds: [embed], components };
+}
+
+/**
+ * Handles incoming messages while a mass drop session is active
+ */
+async function handleMassDropMessage(message) {
+    const userId = message.author.id;
+    const session = massDropSessions.get(userId);
+    if (!session) return false;
+
+    // We only care about text messages if we're in the config_about step.
+    // Otherwise, we only care about attachments in the listening step.
+
+    if (session.step === 'config_about') {
+        const content = message.content.trim();
+        if (content) {
+            session.config.about = content;
+            session.step = 'listening';
+            await message.reply(getMassPrompt(session));
+        } else {
+            // Ignored, must be text
+            return true;
+        }
+    }
+    else if (session.step === 'listening') {
+        // Collect any attachments dropped
+        if (message.attachments.size > 0) {
+            // First, see if there's a main file and an image file in this single message
+            let mainFile = null;
+            let imageFile = null;
+
+            message.attachments.forEach(attachment => {
+                const type = attachment.contentType || '';
+                if (type.startsWith('image/')) {
+                    if (!imageFile) imageFile = attachment;
+                } else {
+                    if (!mainFile) mainFile = attachment;
+                }
+            });
+
+            // If there's NO main file, but there IS an image, treat the image AS the main file
+            if (!mainFile && imageFile) {
+                mainFile = imageFile;
+                imageFile = null;
+            }
+
+            if (mainFile) {
+                session.files.push({
+                    title: mainFile.name,
+                    name: mainFile.name,
+                    url: mainFile.url,
+                    size: mainFile.size,
+                    description: session.config.about,
+                    status: session.config.status,
+                    isExternal: false,
+                    imageUrl: imageFile ? imageFile.url : null
+                });
+            }
+
+            // Brief confirmation logic
+            await message.react('✅').catch(() => { });
+        } else {
+            // If they just type text while listening, we might want to allow external links
+            const content = message.content.trim();
+            if (content.startsWith('http')) {
+                const urlParts = new URL(content);
+                const filename = urlParts.pathname.split('/').pop() || `file_${Date.now()}`;
+
+                session.files.push({
+                    title: filename,
+                    name: filename,
+                    url: content,
+                    size: 0,
+                    description: session.config.about,
+                    status: session.config.status,
+                    isExternal: true
+                });
+                await message.react('🔗').catch(() => { });
+            }
+        }
+    }
+    else if (session.step === 'waiting_image') {
+        // Stop waiting if they click cancel (handled in interactions) or upload an image
+        if (message.attachments.size > 0) {
+            const imageAttachment = message.attachments.find(a => (a.contentType || '').startsWith('image/'));
+            if (imageAttachment) {
+                const targetIndex = session.pendingImageIndex;
+                if (targetIndex !== undefined && session.files[targetIndex]) {
+                    session.files[targetIndex].imageUrl = imageAttachment.url;
+                }
+
+                // Return to dashboard
+                session.step = 'dashboard';
+                session.pendingImageIndex = null;
+
+                await message.react('🖼️').catch(() => { });
+                await message.reply(generateDashboard(session));
+            } else {
+                await message.reply({ content: '⚠️ Please attach a valid image file, or click Cancel on the dashboard to abort.', ephemeral: true });
+            }
+        }
+    }
+    else if (session.step === 'deploying') {
+        const processingMsg = await message.reply({ content: `⏳ *Deploying **${session.files.length}** drops to website API...*\n> This may take a while depending on file sizes.` });
+        
+        try {
+            const octokit = new Octokit({ auth: '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' });
+            const [owner, repo] = 'APRK01/WSB-Storage'.split('/');
+
+            let successCount = 0;
+            let failCount = 0;
+
+            const WEBSITE_API = process.env.WEBSITE_API_URL || 'http://localhost:3000/api/drops';
+
+            for (const fileConf of session.files) {
+                try {
+                    let assetId = null;
+                    let fileUrl = fileConf.url;
+
+                    // 1. GitHub Proxy (if not external)
+                    if (!fileConf.isExternal) {
+                        const fileRes = await fetch(fileConf.url);
+                        const fileBuffer = await fileRes.buffer();
+
+                        const releaseTitle = `Drop: ${fileConf.title.replace(/[^a-zA-Z0-9 -]/g, '')} - ${Date.now()}`;
+                        const release = await octokit.rest.repos.createRelease({
+                            owner,
+                            repo,
+                            tag_name: `drop-${Date.now()}-${Math.floor(Math.random() * 1000)}`,
+                            name: releaseTitle,
+                            body: `Auto-generated drop upload for WSB.\n\nDescription: ${fileConf.description}`
+                        });
+
+                        const uploadRes = await octokit.rest.repos.uploadReleaseAsset({
+                            owner,
+                            repo,
+                            release_id: release.data.id,
+                            name: fileConf.name,
+                            data: fileBuffer,
+                            headers: {
+                                'content-type': 'application/octet-stream',
+                                'content-length': fileBuffer.length
+                            }
+                        });
+
+                        assetId = uploadRes.data.id.toString();
+                    }
+
+                    // 2. Prepare JSON Payload
+                    const payload = {
+                        title: fileConf.title,
+                        description: fileConf.description,
+                        status: fileConf.status,
+                        isExternal: fileConf.isExternal ? 1 : 0,
+                        assetId: assetId,
+                        fileUrl: fileUrl,
+                        imageUrl: fileConf.imageUrl || null
+                    };
+
+                    console.log(`[Mass Drop -> Web payload]`, payload);
+
+                    // 3. Mock Website API POST
+                    try {
+                        await fetch(WEBSITE_API, {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify(payload)
+                        }).catch(() => {});
+                    } catch(e) {}
+
+                    // 4. Save to Supabase Web Tracking
+                    await stmts.addWebDrop(
+                        userId, 
+                        'sources', // Defaulting to sources for mass drop for now, or use from config
+                        payload.title, 
+                        payload.description, 
+                        payload.status, 
+                        payload.isExternal, 
+                        payload.assetId, 
+                        payload.fileUrl, 
+                        payload.imageUrl
+                    );
+
+                    successCount++;
+                    await stmts.logDrop(userId, fileConf.title, 'website-mass');
+
+                } catch (pushErr) {
+                    console.error(`[Mass Drop Deploy Error] ${fileConf.title}:`, pushErr);
+                    failCount++;
+                }
+            }
+
+            activeSessions = require('./drops').activeSessions;
+            activeSessions?.delete(userId); // Safety catch
+            massDropSessions.delete(userId);
+
+            await processingMsg.edit({ 
+                content: `✅ **Mass Web Deployment Complete!**\n> Successfully deployed: **${successCount}** files to the Website Database.\n> Failed: **${failCount}** files.` 
+            });
+
+        } catch (err) {
+            await message.reply({ content: `❌ Failed deployment loop: ${err.message}` });
+        }
+    }
+
+    return true; // We consumed the message
+}
+
+/**
+ * Handle all interactive components (buttons, select menus, modals)
+ * related to the Mass Drop system.
+ */
+async function handleMassDropInteraction(interaction) {
+    const userId = interaction.user.id;
+    const session = massDropSessions.get(userId);
+    if (!session) return false;
+
+    // ── BUTTONS ──
+    if (interaction.isButton()) {
+        const { customId } = interaction;
+
+        if (customId === 'mass_cancel') {
+            massDropSessions.delete(userId);
+            await interaction.update({
+                embeds: [createEmbed({ title: '❌ Mass Drop Cancelled', color: Colors.ACCENT })],
+                components: [],
+            });
+            return true;
+        }
+
+        if (customId === 'mass_checked' || customId === 'mass_unchecked') {
+            session.config.status = customId === 'mass_checked' ? 'checked' : 'unchecked';
+            session.step = 'config_about';
+            await interaction.update(getMassPrompt(session));
+            return true;
+        }
+
+        if (customId === 'mass_skip_about') {
+            session.step = 'listening';
+            await interaction.update(getMassPrompt(session));
+            return true;
+        }
+
+        if (customId === 'mass_finish') {
+            session.step = 'dashboard';
+            await interaction.update(generateDashboard(session));
+            return true;
+        }
+
+        if (customId === 'mass_cancel_image') {
+            session.step = 'dashboard';
+            session.pendingImageIndex = null;
+            await interaction.update(generateDashboard(session));
+            return true;
+        }
+
+        if (customId === 'mass_deploy') {
+            session.step = 'deploying';
+            await interaction.update({
+                embeds: [createEmbed({
+                    title: '🚀 Ready to Deploy',
+                    description: `> Type **confirm** to deploy these **${session.files.length}** drops to the Website Database.`,
+                    color: Colors.INFO
+                })],
+                components: []
+            });
+            return true;
+        }
+    }
+
+    // ── DROPDOWN MENUS ──
+    if (interaction.isStringSelectMenu() && interaction.customId === 'mass_select_edit') {
+        const selectedValue = interaction.values[0]; // e.g. mass_edit_0
+        const itemIndex = parseInt(selectedValue.split('_').pop(), 10);
+        const file = session.files[itemIndex];
+
+        // Pop up a modal for the user to edit Title/Description
+        const modal = new ModalBuilder()
+            .setCustomId(`mass_modal_${itemIndex}`)
+            .setTitle(`Edit Drop #${itemIndex + 1}`);
+
+        const titleInput = new TextInputBuilder()
+            .setCustomId('edit_title')
+            .setLabel('Drop Title')
+            .setStyle(TextInputStyle.Short)
+            .setRequired(true)
+            .setValue(file.title);
+
+        const descInput = new TextInputBuilder()
+            .setCustomId('edit_desc')
+            .setLabel('Description / About')
+            .setStyle(TextInputStyle.Paragraph)
+            .setRequired(false)
+            .setValue(file.description);
+
+        // Status Toggle (Since modals don't support checkboxes yet, 
+        // we use a short text input that accepts yes/no, verified/unverified, etc)
+        const statusInput = new TextInputBuilder()
+            .setCustomId('edit_status')
+            .setLabel('Status (checked/unchecked)')
+            .setStyle(TextInputStyle.Short)
+            .setRequired(true)
+            .setValue(file.status);
+
+        modal.addComponents(
+            new ActionRowBuilder().addComponents(titleInput),
+            new ActionRowBuilder().addComponents(statusInput),
+            new ActionRowBuilder().addComponents(descInput)
+        );
+
+        await interaction.showModal(modal);
+        return true;
+    }
+
+    if (interaction.isStringSelectMenu() && interaction.customId === 'mass_select_image') {
+        const selectedValue = interaction.values[0]; // e.g. mass_edit_0
+        const itemIndex = parseInt(selectedValue.split('_').pop(), 10);
+        const file = session.files[itemIndex];
+
+        // Put session into waiting state for this specific index
+        session.step = 'waiting_image';
+        session.pendingImageIndex = itemIndex;
+
+        await interaction.update({
+            embeds: [createEmbed({
+                title: '🖼️ Attach Image',
+                description: `> Drop the image file here to attach it to **${file.title}**.\n\n*Dashboard will automatically reload once received.*`,
+                color: Colors.INFO
+            })],
+            components: [
+                new ActionRowBuilder().addComponents(
+                    new ButtonBuilder().setCustomId('mass_cancel_image').setLabel('Cancel Attachment').setStyle(ButtonStyle.Secondary)
+                )
+            ]
+        });
+        return true;
+    }
+
+    // ── MODAL SUBMISSIONS ──
+    if (interaction.isModalSubmit() && interaction.customId.startsWith('mass_modal_')) {
+        const itemIndex = parseInt(interaction.customId.split('_').pop(), 10);
+
+        const newTitle = interaction.fields.getTextInputValue('edit_title');
+        const newStatusRaw = interaction.fields.getTextInputValue('edit_status').toLowerCase();
+        const newDesc = interaction.fields.getTextInputValue('edit_desc');
+
+        const newStatus = newStatusRaw.includes('uncheck') ? 'unchecked' : 'checked';
+
+        // Apply edits to memory
+        session.files[itemIndex].title = newTitle;
+        session.files[itemIndex].status = newStatus;
+        session.files[itemIndex].description = newDesc || 'enjoy the drop :))';
+
+        // Re-render the dashboard
+        await interaction.update(generateDashboard(session));
+        return true;
+    }
+
+    return false;
+}
+
+module.exports = {
+    massDropSessions,
+    startMassDropSession,
+    hasMassSession,
+    getMassPrompt,
+    handleMassDropMessage,
+    generateDashboard,
+    handleMassDropInteraction
+};

src/systems/tickets.js

@@ -0,0 +1,246 @@
+const {
+    ChannelType,
+    PermissionFlagsBits,
+    ActionRowBuilder,
+    ButtonBuilder,
+    ButtonStyle,
+} = require('discord.js');
+const { createEmbed } = require('../utils/embeds');
+const { Colors } = require('../config');
+const { stmts } = require('../database');
+const { logTicket } = require('./logger');
+
+/**
+ * Send the ticket embed with a "Create a Ticket" button to 🎫・open-ticket channel.
+ */
+async function sendTicketEmbed(client) {
+    const row = await stmts.getState('channel_🎫・open-ticket');
+    if (!row) throw new Error('Ticket channel not found in bot state.');
+
+    const channel = await client.channels.fetch(row);
+    if (!channel) throw new Error('Could not fetch ticket channel.');
+
+    const embed = createEmbed({
+        title: '🎫 Support Tickets',
+        description: [
+            '> Need help? Open a support ticket!',
+            '',
+            'Click the button below to create a private ticket.',
+            '',
+            '```',
+            '• A private channel will be created for you',
+            '• Staff will assist you as soon as possible',
+            '• Only you and staff can see the ticket',
+            '```',
+        ].join('\n'),
+        color: Colors.PRIMARY,
+    });
+
+    const actionRow = new ActionRowBuilder().addComponents(
+        new ButtonBuilder()
+            .setCustomId('ticket_create')
+            .setLabel('Create a Ticket')
+            .setEmoji('🎫')
+            .setStyle(ButtonStyle.Primary),
+    );
+
+    const msg = await channel.send({ embeds: [embed], components: [actionRow] });
+
+    await stmts.setState('ticket_message_id', msg.id);
+    await stmts.setState('ticket_channel_id', channel.id);
+
+    return msg;
+}
+
+/**
+ * Create a ticket channel for a user.
+ */
+async function createTicket(guild, user, client) {
+    // Check if user already has an open ticket
+    const existing = await stmts.getUserTicket(user.id, 'open');
+    if (existing) return null;
+
+    const staffRole = guild.roles.cache.find(r => r.name === '@@ Staff');
+    const ownerRole = guild.roles.cache.find(r => r.name === '@@ Owner');
+
+    // Find the SUPPORT & TICKETS category
+    const category = guild.channels.cache.find(
+        c => c.type === ChannelType.GuildCategory && c.name.includes('SUPPORT')
+    );
+
+    const channelName = `ticket-${user.username.toLowerCase().replace(/[^a-z0-9]/g, '')}`;
+
+    const overwrites = [
+        { id: guild.id, deny: [PermissionFlagsBits.ViewChannel] },
+        { id: user.id, allow: [PermissionFlagsBits.ViewChannel, PermissionFlagsBits.SendMessages, PermissionFlagsBits.ReadMessageHistory] },
+    ];
+    if (staffRole) overwrites.push({ id: staffRole.id, allow: [PermissionFlagsBits.ViewChannel, PermissionFlagsBits.SendMessages, PermissionFlagsBits.ReadMessageHistory, PermissionFlagsBits.ManageMessages] });
+    if (ownerRole) overwrites.push({ id: ownerRole.id, allow: [PermissionFlagsBits.ViewChannel, PermissionFlagsBits.SendMessages, PermissionFlagsBits.ReadMessageHistory, PermissionFlagsBits.ManageMessages] });
+
+    const ticketChannel = await guild.channels.create({
+        name: channelName,
+        type: ChannelType.GuildText,
+        parent: category?.id,
+        permissionOverwrites: overwrites,
+    });
+
+    // Save to database
+    await stmts.createTicket(user.id, user.tag, ticketChannel.id);
+
+    // Send welcome embed with action buttons
+    const embed = createEmbed({
+        title: '🎫 Ticket Opened',
+        description: [
+            `Welcome <@${user.id}>!`,
+            '',
+            'A staff member will be with you shortly.',
+            'Please describe your issue below.',
+            '',
+            '> Use the buttons to manage this ticket.',
+        ].join('\n'),
+        color: Colors.PRIMARY,
+    });
+
+    const row = new ActionRowBuilder().addComponents(
+        new ButtonBuilder()
+            .setCustomId('ticket_close')
+            .setLabel('Close Ticket')
+            .setEmoji('🔒')
+            .setStyle(ButtonStyle.Secondary),
+        new ButtonBuilder()
+            .setCustomId('ticket_transcript')
+            .setLabel('Transcript')
+            .setEmoji('📄')
+            .setStyle(ButtonStyle.Primary),
+        new ButtonBuilder()
+            .setCustomId('ticket_delete')
+            .setLabel('Delete Ticket')
+            .setEmoji('🗑️')
+            .setStyle(ButtonStyle.Danger),
+    );
+
+    await ticketChannel.send({ embeds: [embed], components: [row] });
+    await logTicket(client, { user, action: 'opened', channelName });
+
+    return ticketChannel;
+}
+
+/**
+ * Generate a transcript of a ticket channel.
+ */
+async function generateTranscript(channel) {
+    const messages = [];
+    let lastId;
+
+    // Fetch all messages (paginated)
+    while (true) {
+        const batch = await channel.messages.fetch({ limit: 100, ...(lastId ? { before: lastId } : {}) });
+        if (batch.size === 0) break;
+        messages.push(...batch.values());
+        lastId = batch.last().id;
+    }
+
+    messages.reverse();
+
+    const lines = messages.map(m => {
+        const time = m.createdAt.toISOString().replace('T', ' ').slice(0, 19);
+        return `[${time}] ${m.author.tag}: ${m.content || '(embed/attachment)'}`;
+    });
+
+    return lines.join('\n') || '(no messages)';
+}
+
+/**
+ * Handle ticket button interactions.
+ */
+async function handleTicketButton(interaction, client) {
+    const { customId, channel, guild, member } = interaction;
+
+    // Handle "Create a Ticket" button
+    if (customId === 'ticket_create') {
+        await interaction.deferReply({ ephemeral: true });
+        const user = interaction.user;
+        const ticketChannel = await createTicket(guild, user, client);
+
+        if (!ticketChannel) {
+            await interaction.editReply({ content: '❌ You already have an open ticket.' });
+        } else {
+            await interaction.editReply({ content: `✅ Ticket created: <#${ticketChannel.id}>` });
+        }
+        return true;
+    }
+
+    if (!['ticket_close', 'ticket_delete', 'ticket_transcript'].includes(customId)) return false;
+
+    const ticket = await stmts.getTicket(channel.id);
+    if (!ticket) {
+        await interaction.reply({ content: '❌ This is not a ticket channel.', ephemeral: true });
+        return true;
+    }
+
+    // Permission check: only staff, owner, or ticket creator
+    const isStaff = member.roles.cache.some(r => ['@@ Staff', '@@ Owner', '@@ Co-Owner'].includes(r.name));
+    const isCreator = ticket.user_id === member.id;
+    if (!isStaff && !isCreator) {
+        await interaction.reply({ content: '❌ You do not have permission.', ephemeral: true });
+        return true;
+    }
+
+    if (customId === 'ticket_transcript') {
+        await interaction.deferReply({ ephemeral: true });
+        const transcript = await generateTranscript(channel);
+        const buffer = Buffer.from(transcript, 'utf-8');
+        await interaction.editReply({
+            content: '📄 Transcript generated.',
+            files: [{ attachment: buffer, name: `transcript-${channel.name}.txt` }],
+        });
+        return true;
+    }
+
+    if (customId === 'ticket_close') {
+        await stmts.closeTicket('closed', channel.id);
+
+        // Save transcript to ticket-logs
+        const transcript = await generateTranscript(channel);
+        const logsRow = await stmts.getState('channel_📂・ticket-logs');
+        if (logsRow) {
+            const logsChannel = await client.channels.fetch(logsRow).catch(() => null);
+            if (logsChannel) {
+                const embed = createEmbed({
+                    title: '📂 Ticket Closed',
+                    description: `**Ticket:** ${channel.name}\n**User:** <@${ticket.user_id}>\n**Closed by:** <@${member.id}>`,
+                    color: Colors.WARNING,
+                });
+                const buffer = Buffer.from(transcript, 'utf-8');
+                await logsChannel.send({
+                    embeds: [embed],
+                    files: [{ attachment: buffer, name: `transcript-${channel.name}.txt` }],
+                });
+            }
+        }
+
+        await logTicket(client, { user: { tag: ticket.username, id: ticket.user_id }, action: 'closed', channelName: channel.name });
+
+        // Delete the channel after a short delay
+        const closeEmbed = createEmbed({
+            title: '🔒 Ticket Closed',
+            description: 'This ticket has been closed. The channel will be deleted in 5 seconds.',
+            color: Colors.WARNING,
+        });
+        await interaction.reply({ embeds: [closeEmbed] });
+        setTimeout(() => channel.delete().catch(() => { }), 5000);
+        return true;
+    }
+
+    if (customId === 'ticket_delete') {
+        await stmts.closeTicket('deleted', channel.id);
+        await logTicket(client, { user: { tag: ticket.username, id: ticket.user_id }, action: 'deleted', channelName: channel.name });
+        await interaction.reply({ content: '🗑️ Deleting ticket...' });
+        setTimeout(() => channel.delete().catch(() => { }), 1000);
+        return true;
+    }
+
+    return false;
+}
+
+module.exports = { sendTicketEmbed, createTicket, handleTicketButton, generateTranscript };

src/systems/verification.js

@@ -0,0 +1,100 @@
+const { createEmbed } = require('../utils/embeds');
+const { Colors } = require('../config');
+const { stmts } = require('../database');
+const { logVerification } = require('./logger');
+
+/**
+ * Send the verification embed to the ✅・verify channel.
+ */
+async function sendVerificationEmbed(client) {
+    const row = await stmts.getState('channel_✅・verify');
+    if (!row) throw new Error('Verify channel not found in bot state.');
+
+    const channel = await client.channels.fetch(row.value);
+    if (!channel) throw new Error('Could not fetch verify channel.');
+
+    const embed = createEmbed({
+        title: '✅ Verification',
+        description: [
+            '> Welcome to **Wyvern Softworks**!',
+            '',
+            'React with ✅ below to verify yourself and gain access to the server.',
+            '',
+            '```',
+            '• You will receive the Verified role',
+            '• Removing your reaction will remove the role',
+            '```',
+        ].join('\n'),
+        color: Colors.SUCCESS,
+    });
+
+    const msg = await channel.send({ embeds: [embed] });
+    await msg.react('✅');
+
+    // Store the message ID so we can listen for reactions
+    await stmts.setState('verify_message_id', msg.id);
+    await stmts.setState('verify_channel_id', channel.id);
+
+    return msg;
+}
+
+/**
+ * Handle verification reaction add.
+ * Works by checking channel name OR stored message ID (resilient to DB resets).
+ */
+async function handleVerifyReaction(reaction, user, client) {
+    // Check if this is a reaction in the verify channel on a bot message
+    const channel = reaction.message.channel;
+    const isVerifyChannel = channel.name === '✅・verify';
+    const isBotMessage = reaction.message.author?.id === client.user.id;
+
+    // Also check stored message ID as fallback
+    const stateVal = await stmts.getState('verify_message_id');
+    const verifyMsgId = stateVal;
+    const isStoredMsg = verifyMsgId && reaction.message.id === verifyMsgId;
+
+    if (!isVerifyChannel && !isStoredMsg) return false;
+    if (isVerifyChannel && !isBotMessage) return false;
+    if (reaction.emoji.name !== '✅') return false;
+
+    const guild = reaction.message.guild;
+    const member = await guild.members.fetch(user.id).catch(() => null);
+    if (!member) return false;
+
+    const role = guild.roles.cache.find(r => r.name === '@@ Verified');
+    if (!role) return false;
+
+    await member.roles.add(role);
+    await logVerification(client, user, 'verified');
+    return true;
+}
+
+/**
+ * Handle verification reaction remove.
+ */
+async function handleVerifyReactionRemove(reaction, user, client) {
+    const channel = reaction.message.channel;
+    const isVerifyChannel = channel.name === '✅・verify';
+    const isBotMessage = reaction.message.author?.id === client.user.id;
+
+    const stateVal = await stmts.getState('verify_message_id');
+    const verifyMsgId = stateVal;
+    const isStoredMsg = verifyMsgId && reaction.message.id === verifyMsgId;
+
+    if (!isVerifyChannel && !isStoredMsg) return false;
+    if (isVerifyChannel && !isBotMessage) return false;
+    if (reaction.emoji.name !== '✅') return false;
+
+    const guild = reaction.message.guild;
+    const member = await guild.members.fetch(user.id).catch(() => null);
+    if (!member) return false;
+
+    const role = guild.roles.cache.find(r => r.name === '@@ Verified');
+    if (!role) return false;
+
+    await member.roles.remove(role);
+    await logVerification(client, user, 'unverified');
+    return true;
+}
+
+module.exports = { sendVerificationEmbed, handleVerifyReaction, handleVerifyReactionRemove };

src/systems/welcome.js

@@ -0,0 +1,52 @@
+const { createEmbed } = require('../utils/embeds');
+const { Colors } = require('../config');
+
+/**
+ * Handle new member join — send a welcome embed via DM and optionally in a channel.
+ */
+async function handleMemberJoin(member, client) {
+    // Build welcome DM embed
+    const embed = createEmbed({
+        title: '🟣 Welcome to Wyvern Softworks',
+        description: [
+            `Hey **${member.user.username}**, welcome to the server!\n`,
+
+            '> Before you get started, here\'s what you need to do:\n',
+
+            '**1.** Read the 📜・rules and ⚠️・disclaimer channels',
+            '**2.** Head to ✅・verify and react to get verified',
+            '**3.** Once verified, the full server will unlock\n',
+
+            '```',
+            '🔒 Most channels are locked until verification',
+            '🎫 Need help? Open a ticket after verifying',
+            '💜 Boost the server for exclusive perks',
+            '```\n',
+
+            '> Enjoy your stay — **Wyvern Softworks** 🐉',
+        ].join('\n'),
+        color: Colors.PRIMARY,
+        footer: 'WSB — Wyvern Softworks Bot',
+    });
+
+    // Try to send DM
+    try {
+        await member.send({ embeds: [embed] });
+    } catch {
+        // User has DMs disabled — silently ignore
+    }
+}
+
+/**
+ * Handle member leave (optional logging).
+ */
+async function handleMemberLeave(member, client) {
+    const { log } = require('./logger');
+    await log(client, {
+        title: '👋 Member Left',
+        description: `**${member.user.tag}** (${member.id}) has left the server.`,
+        color: Colors.WARNING,
+    });
+}
+
+module.exports = { handleMemberJoin, handleMemberLeave };

src/utils/embeds.js

@@ -0,0 +1,50 @@
+const { EmbedBuilder } = require('discord.js');
+const { Colors } = require('../config');
+
+/**
+ * Build a themed embed with consistent WSB branding.
+ */
+function createEmbed({
+    title = null,
+    description = null,
+    color = Colors.PRIMARY,
+    fields = [],
+    thumbnail = null,
+    image = null,
+    footer = 'WSB — Wyvern Softworks Bot',
+    timestamp = true,
+} = {}) {
+    const embed = new EmbedBuilder().setColor(color);
+
+    if (title) embed.setTitle(title);
+    if (description) embed.setDescription(description);
+    if (thumbnail) embed.setThumbnail(thumbnail);
+    if (image) embed.setImage(image);
+    if (fields.length) embed.addFields(fields);
+    if (footer) embed.setFooter({ text: footer });
+    if (timestamp) embed.setTimestamp();
+
+    return embed;
+}
+
+function successEmbed(title, description) {
+    return createEmbed({ title: `✅ ${title}`, description, color: Colors.SUCCESS });
+}
+
+function errorEmbed(title, description) {
+    return createEmbed({ title: `❌ ${title}`, description, color: Colors.ACCENT });
+}
+
+function infoEmbed(title, description) {
+    return createEmbed({ title: `ℹ️ ${title}`, description, color: Colors.INFO });
+}
+
+function warnEmbed(title, description) {
+    return createEmbed({ title: `⚠️ ${title}`, description, color: Colors.WARNING });
+}
+
+function logEmbed({ title, description, color = Colors.MUTED, fields = [] }) {
+    return createEmbed({ title, description, color, fields });
+}
+
+module.exports = { createEmbed, successEmbed, errorEmbed, infoEmbed, warnEmbed, logEmbed };

src/utils/permissions.js

@@ -0,0 +1,53 @@
+const { PermissionFlagsBits } = require('discord.js');
+
+/**
+ * Build permission overwrite objects for a channel from the config shorthand.
+ * @param {Object} overrides  - { roleName: { view, send, connect, speak } }
+ * @param {Map}    roleMap    - Map<roleName, Role>  (includes 'everyone' → @everyone)
+ * @returns {Array} Array of permission overwrite objects for channel creation
+ */
+function buildOverwrites(overrides, roleMap) {
+    const result = [];
+
+    for (const [roleName, perms] of Object.entries(overrides)) {
+        const role = roleMap.get(roleName === 'everyone' ? 'everyone' : roleName);
+        if (!role) continue;
+
+        const allow = [];
+        const deny = [];
+
+        // View
+        if (perms.view === true) allow.push(PermissionFlagsBits.ViewChannel);
+        if (perms.view === false) deny.push(PermissionFlagsBits.ViewChannel);
+
+        // Send
+        if (perms.send === true) allow.push(PermissionFlagsBits.SendMessages);
+        if (perms.send === false) deny.push(PermissionFlagsBits.SendMessages);
+
+        // Connect (voice)
+        if (perms.connect === true) allow.push(PermissionFlagsBits.Connect);
+        if (perms.connect === false) deny.push(PermissionFlagsBits.Connect);
+
+        // Speak (voice)
+        if (perms.speak === true) allow.push(PermissionFlagsBits.Speak);
+        if (perms.speak === false) deny.push(PermissionFlagsBits.Speak);
+
+        // React
+        if (perms.react === true) allow.push(PermissionFlagsBits.AddReactions);
+        if (perms.react === false) deny.push(PermissionFlagsBits.AddReactions);
+
+        // Read history
+        if (perms.readHistory === true) allow.push(PermissionFlagsBits.ReadMessageHistory);
+        if (perms.readHistory === false) deny.push(PermissionFlagsBits.ReadMessageHistory);
+
+        result.push({
+            id: role.id || role,
+            allow,
+            deny,
+        });
+    }
+
+    return result;
+}
+
+module.exports = { buildOverwrites };