Upload folder using huggingface_hub

.changeset/config.json

@@ -0,0 +1,12 @@
+{
+    "$schema": "https://unpkg.com/@changesets/[email protected]/schema.json",
+    "changelog": ["@changesets/changelog-github", { "repo": "nebulaservices/nebula" }],
+    "commit": false,
+    "fixed": [],
+    "linked": [],
+    "access": "public",
+    "baseBranch": "main",
+    "updateInternalDependencies": "patch",
+    "ignore": [],
+    "privatePackages": { "version": true, "tag": true }
+}

.dockerignore

@@ -0,0 +1,17 @@
+node_modules/
+.vscode
+npm-debug.log
+yarn-error.log
+.github/
+.env.example
+.env
+dist/
+.git/
+.astro/
+~/
+.gitignore
+biome.json
+docker-compose.yml
+Dockerfile
+README.md
+db/

.gitattributes

@@ -1,35 +1,37 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+database_assets/com.nebula.retro/terminal.ttf filter=lfs diff=lfs merge=lfs -text
+src/assets/credits/motortruck1221.png filter=lfs diff=lfs merge=lfs -text

.github/workflows/docker.yml

@@ -0,0 +1,48 @@
+name: Build Docker image
+on:
+  push:
+    tags:
+      - v*
+  workflow_dispatch:
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}
+
+jobs:
+  build-and-push:
+    name: Build and push Docker image to registry
+    runs-on: ubuntu-latest
+    if: github.repository_owner == 'nebulaservices'
+    permissions:
+      contents: write
+      packages: write
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v3
+      - name: Setup docker buildx
+        uses: docker/setup-buildx-action@v3
+      - name: Login To registry ${{ env.REGISTRY }}
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ github.token }}
+      - name: Extract Docker metadata
+        id: meta
+        uses: docker/metadata-action@v3
+        with:
+          images: ${{ env.REGISTRY }}/nebulaservice/nebula
+      - name: Build and push
+        id: build-and-push
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64
+          file: ./Dockerfile
+          name: nebula
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max

.github/workflows/release.yml

@@ -0,0 +1,50 @@
+name: Release
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+defaults:
+  run:
+    shell: bash
+
+env:
+  FORCE_COLOR: true
+
+jobs:
+  changelog:
+    name: Release TAG
+    if: ${{ github.repository_owner == 'nebulaservices' }}
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup PNPM
+        uses: pnpm/action-setup@v3
+        with:
+          version: 9.1.1
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 18
+          cache: "pnpm"
+
+      - name: Install dependencies
+        run: pnpm install --no-frozen-lockfile
+
+      - name: Create Release Pull Request or Publish
+        id: changesets
+        uses: changesets/action@v1
+        with:
+          version: pnpm run version
+          publish: pnpm exec changeset publish
+          commit: "[ci] release"
+          title: "[ci] release"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -0,0 +1,43 @@
+# build output
+dist/
+server/*.js
+
+# generated types
+.astro/
+
+# dependencies
+node_modules/
+package-lock.json
+
+#external assets
+database_assets/
+!database_assets/com.nebula.gruvbox/
+!database_assets/com.nebula.lightTheme/
+!database_assets/com.nebula.oled/
+!database_assets/com.nebula.retro/
+
+# logs
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# environment variables
+.env
+.env.production
+
+# macOS-specific files
+.DS_Store
+
+# jetbrains setting folder
+.idea/
+
+# nebula catalog database
+database.sqlite
+
+
+# YOUR config
+config.toml
+
+# Goofy PNPM problem
+~/

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "workerware"]
+	path = workerware
+	url = https://github.com/mercuryworkshop/workerware

.vscode/extensions.json

@@ -0,0 +1,4 @@
+{
+    "recommendations": ["astro-build.astro-vscode"],
+    "unwantedRecommendations": []
+}

.vscode/launch.json

@@ -0,0 +1,11 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "command": "./node_modules/.bin/astro dev",
+            "name": "Development server",
+            "request": "launch",
+            "type": "node-terminal"
+        }
+    ]
+}

CHANGELOG.md

@@ -0,0 +1,17 @@
+# v9.0.0
+
+- The first release of Nebula V9! And with it bring a whole host of changes:
+  - More stable the V8
+  - Adds a Marketplace where users can create their own themes & plugins
+  - Switches to Astro for speed
+  - Other general bug fixes
+
+# v9.0.1
+
+- Bumps dependencies
+- Fixes bugs
+
+# 9.0.2
+
+- Adds the ability for a custom wisp server back
+- Increases upload fileSize capacity in hopes that bigger files can now be uploaded

Dockerfile

@@ -0,0 +1,19 @@
+FROM node:22-alpine
+
+WORKDIR /app
+
+COPY package*.json .
+COPY . .
+
+RUN apk update
+RUN apk add python3 py3-pip alpine-sdk openssl-dev build-base python3-dev
+RUN python3 -m pip install setuptools --break-system-packages
+RUN cp -n config.example.toml config.toml 
+RUN npm i -g pnpm
+RUN pnpm install
+RUN pnpm run build
+RUN export TERM=xterm-256color
+VOLUME /app
+EXPOSE 8080
+ENTRYPOINT ["pnpm"]
+CMD ["start", "--color"]

README.md

@@ -1,10 +1,373 @@
----
-title: Nebula2
-emoji: 😻
-colorFrom: indigo
-colorTo: blue
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+sdk: gradio
+---
+<div align="center">
+         
+<img src="https://socialify.git.ci/nebulaservices/nebula/image?description=1&font=Inter&forks=1&issues=1&language=1&name=1&owner=1&pattern=Circuit%20Board&pulls=1&stargazers=1&theme=Dark" alt="ruby" width="640" height="320" />
+
+<img alt="repo size" src="https://img.shields.io/github/repo-size/nebulaservices/nebula?style=for-the-badge"></img>
+<img alt="website status" src="https://img.shields.io/website?url=https%3A%2F%2Fnebulaproxy.io&style=for-the-badge"></img>
+<img alt="commit a week" src="https://img.shields.io/github/commit-activity/w/nebulaservices/nebula?style=for-the-badge"></img>
+
+</div>
+
+<div align="center">
+    <h2>Get Started</h2>
+    <a>To get started, press one of the buttons below to deploy Nebula</a>
+    <br />
+    <br />
+    <a href="#terminal">
+        <img src="https://img.shields.io/badge/terminal-%23121011.svg?style=for-the-badge&logo=gnu-bash&logoColor=white" alt="Terminal">
+        </img>
+    </a>
+    <a href="#docker">
+        <img src="https://img.shields.io/badge/docker-%230db7ed.svg?style=for-the-badge&logo=docker&logoColor=white" alt="Docker">
+        </img>
+    </a>
+</div>
+
+## NOTE:
+
+-   This will **NOT** deploy on GitHub Pages, Netlify, Vercel, Gitlab Pages, or any other _static_ host
+-   This will **NOT** work on Render
+---
+
+## How to get links
+
+[![Nebula Services Discord](https://invidget.switchblade.xyz/unblocker?theme=darl)](https://discord.gg/unblocker)
+[![Titanium Network Discord](https://invidget.switchblade.xyz/unblock?theme=dark)](https://discord.gg/unblock)
+
+---
+
+## Features
+
+-   Multiple Proxy "Backends":
+    -   [Ultraviolet](https://github.com/titaniumnetwork-dev/ultraviolet)
+    -   [RammerHead](https://github.com/binary-person/rammerhead)
+---
+
+## Contributors
+
+- [Rifting](https://github.com/rifting) - Owner & Maintainer
+- [MotorTruck1221](https://motortruck1221.com) - Maintainer
+---
+
+## Tech Stack
+
+-   [Astro](https://astro.build)
+-   [Fastify](https://fastify.dev)
+-   [Ultraviolet](https://github.com/titaniumnetwork-dev/ultraviolet)
+-   [RammerHead](https://github.com/binary-person/rammerhead)
+-   [Epoxy](https://github.com/mercuryworkshop/epoxy-tls)
+-   [Libcurl.js](https://github.com/ading2210/libcurl.js)
+-   HTML, CSS, and JavaScript (DUH)
+---
+
+## Catalog/Marketplace
+
+- By default, the marketplace is enabled and uses SQLite
+- If you would like to disable the catalog, see [#config](#config)
+- For big production instances, I recommend using PostgreSQL rather than SQLite. To do this see [#config](#config)
+- To use PostgreSQL via the provided docker-compose files, see [#docker](#docker)
+
+### How to make a theme
+
+- Themes allow you to customize Nebula's *look*.
+
+#### Prerequisites:
+  - Make sure you have our [Discord server](https://discord.gg/unblocker) so you can submit your theme
+
+##### Making the themes:
+
+1. Firstly, copy the CSS vars:
+```css
+:root {
+    --background-primary: /*Your stuff here */;
+    --background-lighter: ;
+    --navbar-color: ;
+    --navbar-text-color: ;
+    --navbar-link-color: ; 
+    --navbar-link-hover-color: ; 
+    --input-text-color: ;
+    --input-placeholder-color: ; 
+    --input-background-color: ;
+    --input-border-color: ;
+    --tab-color: ;
+    --border-color: ; 
+}
+```
+
+> [!NOTE]
+>
+> You can add a custom font as well! To do so, add this to your `:root`
+> 
+> ```css
+> --font-family: /* Font family name */;
+> ```
+> 
+> And this to the bottom of your CSS file/submission:
+> ```css
+> @font-face {
+>    font-family: /* Name */;
+>    src: url(/* Where the font is located! Local or external work! */);
+>   }
+>  ```
+>
+> A good example of using a custom font is the built-in `retro` theme [here](./database_assets/com.nebula.retro)
+
+2. Add your colors and test! (Either with a self-hosted version of Nebula OR via a live preview (no clue when this will happen)
+
+3. Once you're satisfied with the colors, submit your theme to the [Discord Server](https://discord.gg/unblocker)!
+
+---
+### How to make a plugin
+
+- Plugins extend the functionality of either the proxied page(s) or the service worker.
+- This guide provides an incredibly basic example of how to make either.
+
+#### Prerequisites:
+  - Make sure you have joined our [Discord server](https://discord.gg/unblocker) so you can submit your plugin.
+  - Some knowledge of JS/TS
+
+##### Serviceworker plugin:
+
+- These plugins are handled by Workerware see [here](https://github.com/mercuryworkshop/workerware) for docs.
+
+1. Create an index.js (or other file name) file:
+```bash
+touch index.js
+```
+
+2. Edit that file to include either of these:
+    - Code encased in a string:
+    ```js
+    function setup() {
+        // This function MUST return the following attributes:
+        return {
+            function: `console.log('Example code.')`,
+            name: 'com.example', // Technically, it could be named anything. It is recommended to use the same name for everything (name when submitting and this)        
+            events: ['fetch'] // See: https://github.com/mercuryworkshop/workerware for the event types you can use. (Also typed if you are using typescript)
+        }
+    }
+    
+    //This can be named anything. However, it's recommended to use `entryFunc` (with types, the naming IS enforced)
+    self.entryFunc = setup; //DO NOT call the function here. Only assign the reference otherwise, it will error.
+    ```
+    - Code in an arrow function:    
+    ```js
+    const example = () => {
+        console.log('Example code')
+    }
+
+    function setup() {
+        //This function MUST return the following attributes:
+        return {
+            function: example, //Do not call the function, only assign the reference to the function.
+            name: 'com.example', // Technicall could be name anything. Recommended to use the same name for everything (name when submitting and this)
+            event: ['fetch'] // Se https://github.com/mercuryworkshop/workerware for the event types you can use. (Also typed if using typescript)
+        }
+    }
+
+    //This can be named anything. However, it's recommended to use `entryFunc` (with types, the naming IS enforced)
+    self.entryFunc = setup; //DO NOT call the function here. Only assign the reference; otherwise, it will result in an error.
+    ```
+
+> [!WARNING]
+> The only *allowed* way to pass code to the `function` param is either a string or an arrow function. Named functions ***WILL NOT WORK***.
+>
+> Example of a named function: `function example() {/* Some form of code */}`.
+>
+> If a named function is used where it shouldn't be, your plugin will not be approved, nor will it work properly.
+
+3. Submit your plugin in the [Discord](https://discord.gg/unblocker)!
+
+##### Proxied page plugins
+
+- They allow modification of websites that UV proxies, (EX: you could add Vencord to Discord with this)
+
+1. Create an index.js file (or another file name)
+```bash
+touch index.js
+```
+
+2. Edit that file with your code and the following:
+```js
+//Name this whatever.
+function example() {
+    //You MUST return the following
+    return {
+        host: "example.com", //The host to match (so if the user visits example.com it will inject the html below.
+        html: "<script>console.log('Example')</script>", //Must return a string (and be valid HTML or your plugin will break). How you get that string is up to you
+        injectTo: "head" // Can be "head" or "body"
+    }
+}
+
+// Technically, this could be named anything, it is recommended to call it `entryFunc`
+self.entryFunc = example; //DO NOT run the function here. That will cause errors. Only assign the reference to the function here.
+```
+
+3. Submit it in our [Discord](https://discord.gg/unblocker)!
+
+---
+
+## Deployment
+
+### Terminal
+
+Prerequisites:
+- Node & npm
+- Git
+
+1. Clone the repo:
+```bash
+git clone https://github.com/nebulaservices/nebula --recursive && cd nebula
+```
+
+2. Install all of the dependencies:
+```bash
+npm i
+```
+
+3. Create a `config.toml` file
+```bash
+cp config.example.toml config.toml
+```
+
+4. Modify the `config.toml` file to your liking (docs [here](#environment))
+```
+nano config.toml
+```
+
+5. Build the front end & server:
+```bash
+npm run build
+```
+
+6. Start the server
+```bash
+npm start
+```
+
+> [!NOTE]
+> You can run `npm run bstart` to build and start together
+---
+
+### Docker
+
+- There are two ways to deploy with docker:
+    - [Normal docker](#normal-docker)
+    - [Docker Compose](#docker-compose)
+
+#### Normal Docker
+
+Prerequisites:
+- Git
+- Docker
+
+1. Clone the repo (skip if using a prebuilt image):
+```bash
+git clone https://github.com/nebulaservices/nebula --recursive && cd nebula
+```
+
+2. Create an `config.toml` file (if using prebuilt image, copy the example from the repo):
+```bash
+cp config.example.toml config.toml
+```
+
+3. Modify the `config.toml` file to your liking (docs [here](#environment))
+```bash
+nano config.toml
+```
+
+4. Build the docker image (skip if using prebuilt):
+```bash
+docker build nebula:latest
+```
+5. Run the docker images:
+
+    - Prebuilt:
+    ```bash
+    docker run -v ./config.toml:/app/config.toml ghcr.io/nebulaservices/nebula:latest
+    ```
+    - Image you built yourself:
+    ```bash
+    docker run -v ./config.toml:/app/config.toml nebula:latest
+    ```
+
+#### Docker Compose
+
+Prerequisites:
+- Git
+- Docker w/compose
+
+1. Clone the repo (skip if using a prebuilt image):
+```bash
+git clone https://github.com/nebulaservices/nebula --recursive
+```
+
+2. Create an `config.toml` file (if using prebuilt image, copy the example from the repo):
+```bash
+cp config.example.toml config.toml
+```
+
+3. Modify the `config.toml` file to your liking (docs on that [here](#environment)]
+```bash
+nano config.toml
+```
+
+4. Build the docker image (skip if using prebuilt):
+```bash
+docker compose -f ./docker-compose.build.yml build
+```
+
+5. Run the docker image:
+
+    - Prebuilt:
+    ```bash
+    docker compose up
+    ```
+    - Image you built yourself:
+    ```bash
+    docker compose -f ./docker-compose.build.yml up
+    ```
+#### Extra (Postgres)
+
+- To use Postgres over SQLite, uncomment the DB section in the `docker-compose` file (or use your own Postgres DB!). Then, modify the `config.toml` (See: [#config](#config) for knowledge on how to do this)
+- To use Postgres over SQLite in a normal docker environment (no compose), you'll have to set one up and then modify the `config.toml` to use it. (See: [#config](#config) for knowledge on how to do this)
+
+---
+
+## Config
+
+There are a couple of configuration options for Nebula. The defaults are fine most of the time, but there are instances where you may not want certain options enabled or certain things running.
+- An example config file is located [here](./config.example.toml). 
+- Config format is in TOML
+
+| Variable | Description | Type | Default |
+|:----------:|:-------------:|:------:|:---------:|
+| `marketplace` | The options below are for the marketplace section | `object` | N/A |
+| `enabled` | Enable marketplace functionality | `boolean` | `true` |
+| `psk` | The password and authentication key for the marketplace. ***CHANGE FROM DEFAULT*** | `string` | `CHANGEME` |
+|----------------------------| ----------------------------------------------------------------------------|------------|--------------|
+| `db` | The below options are for the db (database) section | `object` | N/A |
+| `name` | The database name to use | `string` | `database` |
+| `username` | The username for the DB | `string` | `username` |
+| `password` | The database password. ***CHANGE FROM DEFAULT VALUE*** | `string` | `password` |
+| `postgres` | Whether to use postgres over sqlite *(recommended for large production instances)* | `boolean` | `false` |
+|----------------------------| ----------------------------------------------------------------------------|------------|--------------|
+| `postgres` | The below options are for the postgres section. (Only worry about this if you enabled postgres in the db section.) | `object` | N/A |
+| `domain` | Either the TLD or the IP address of your postgres server. | `string` | `''` |
+| `port` | The port your postgres server is listening on | `number` | `5432` |
+|----------------------------| ----------------------------------------------------------------------------|------------|--------------|
+| `server.server` | The below options are to configure the server. | `object` | N/A |
+| `port` | What port the server should listen on. *(Note: Can also be configured via environment variable `PORT`)* | `number` | `8080` |
+| `wisp` | Whether the server should use the inbuilt wisp server. (Disabled if your using an external wisp server) | `boolean` | `true` |
+| `logging` | Whether or not to enable logging. *Note: Logs are massive* | `boolean` | `true` |
+|----------------------------| ----------------------------------------------------------------------------|------------|--------------|
+
+## Deploying
+### Koyeb
+- Fork this repo
+- Create new koyeb service, and select webservice
+- Select import from github and import your forked repo
+- Change package to dockerfile and press deploy!

app.py

@@ -0,0 +1,70 @@
+import os
+import shutil
+from flask import Flask, send_from_directory, abort, render_template_string
+import subprocess
+
+# リポジトリをクローンするディレクトリ
+temp_dir = "./"
+
+# リポジトリのクローンとセットアップを行う
+def clone_and_setup_repo():
+
+    os.system("npm i")
+
+    # server/server.ts の fastifyHelmet 設定を置換する ← 追加
+    print("Patching server.ts for iframe embedding...")
+    os.system(r"""sed -i.bak '/fastifyHelmet/s/});/    frameguard: false\\n});/' server/server.ts""")
+
+    os.system("cp config.example.toml config.toml")
+    os.system("npm run build")
+    os.system("npm start")
+
+    # index.htmlをカレントディレクトリに移動
+    index_html_path = os.path.join(temp_dir, 'index.html')
+    if os.path.exists(index_html_path):
+        if os.path.exists('index.html'):
+            os.remove('index.html')
+        shutil.move(index_html_path, '.')
+
+    # 静的ファイルをstaticディレクトリに移動
+    if not os.path.exists('static'):
+        os.mkdir('static')
+    for item in os.listdir(temp_dir):
+        if item != 'index.html':
+            shutil.move(os.path.join(temp_dir, item), os.path.join('static', item))
+
+# クローンとセットアップを実行
+clone_and_setup_repo()
+
+# Flaskアプリケーションの設定
+app = Flask(__name__)
+
+# ルートでindex.htmlを表示
+@app.route('/')
+def index():
+    # index.htmlが存在しない場合は404エラー
+    if not os.path.exists("index.html"):
+        return abort(404, description="index.html not found.")
+
+    # index.htmlの内容を読み込む
+    with open("index.html", "r") as file:
+        index_html_content = file.read()
+
+    return render_template_string(index_html_content)
+
+# 静的ファイルを提供するためのルート
+@app.route('/<path:filename>')
+def static_files(filename):
+    return send_from_directory('static', filename)
+
+# main.jsの存在を確認するエンドポイント
+@app.route('/check_main_js')
+def check_main_js():
+    if os.path.exists('static/main.js'):
+        return "main.js exists."
+    else:
+        return "main.js does not exist."
+
+if __name__ == '__main__':
+    # port 7860でFlaskアプリを起動
+    app.run(host='0.0.0.0', port=7860)

astro.config.ts

@@ -0,0 +1,118 @@
+import { fileURLToPath } from "node:url";
+import node from "@astrojs/node";
+import svelte from "@astrojs/svelte";
+import tailwind from "@astrojs/tailwind";
+import { baremuxPath } from "@mercuryworkshop/bare-mux/node";
+import { epoxyPath } from "@mercuryworkshop/epoxy-transport";
+import { libcurlPath } from "@mercuryworkshop/libcurl-transport";
+import playformCompress from "@playform/compress";
+import { uvPath } from "@titaniumnetwork-dev/ultraviolet";
+import icon from "astro-icon";
+import { defineConfig, envField } from "astro/config";
+import { viteStaticCopy } from "vite-plugin-static-copy";
+import { version } from "./package.json";
+import { parsedDoc } from "./server/config.js";
+const workerwarePath = fileURLToPath(new URL("./workerware/src", import.meta.url));
+
+export default defineConfig({
+    experimental: {
+        env: {
+            schema: {
+                VERSION: envField.string({
+                    context: "client",
+                    access: "public",
+                    optional: true,
+                    default: version
+                }),
+                MARKETPLACE_ENABLED: envField.boolean({
+                    context: "client",
+                    access: "public",
+                    optional: true,
+                    default: parsedDoc.marketplace.enabled
+                })
+            }
+        }
+    },
+    integrations: [
+        tailwind(),
+        icon(),
+        svelte(),
+        playformCompress({
+            CSS: false,
+            HTML: true,
+            Image: true,
+            JavaScript: true,
+            SVG: true
+        })
+    ],
+    vite: {
+        plugins: [
+            viteStaticCopy({
+                targets: [
+                    {
+                        src: `${uvPath}/**/*`.replace(/\\/g, "/"),
+                        dest: "uv",
+                        overwrite: false
+                    },
+                    {
+                        src: `${epoxyPath}/**/*`.replace(/\\/g, "/"),
+                        dest: "epoxy",
+                        overwrite: false
+                    },
+                    {
+                        src: `${libcurlPath}/**/*`.replace(/\\/g, "/"),
+                        dest: "libcurl",
+                        overwrite: false
+                    },
+                    {
+                        src: `${baremuxPath}/**/*`.replace(/\\/g, "/"),
+                        dest: "baremux",
+                        overwrite: false
+                    },
+                    {
+                        src: `${workerwarePath}/**/*`.replace(/\\/g, "/"),
+                        dest: "workerware",
+                        overwrite: false
+                    }
+                ]
+            })
+        ],
+        server: {
+            proxy: {
+                "/api/catalog-stats": {
+                    target: "http://localhost:8080/api/catalog-stats",
+                    changeOrigin: true,
+                    rewrite: (path) => path.replace(/^\/api\/catalog-stats/, "")
+                },
+                "/api/catalog-assets": {
+                    target: "http://localhost:8080/api/catalog-assets",
+                    changeOrigin: true,
+                    rewrite: (path) => path.replace(/^\/api\/catalog-assets/, "")
+                },
+                "/api/packages": {
+                    target: "http://localhost:8080/api/packages",
+                    changeOrigin: true,
+                    rewrite: (path) => path.replace(/^\/api\/packages/, "")
+                },
+                "/packages": {
+                    target: "http://localhost:8080",
+                    changeOrigin: true
+                },
+                "/wisp/": {
+                    target: "ws://localhost:8080/wisp/",
+                    changeOrigin: true,
+                    ws: true,
+                    rewrite: (path) => path.replace(/^\/wisp\//, "")
+                },
+                "/styles": {
+                    target: "http://localhost:8080",
+                    changeOrigin: true
+                }
+            }
+        }
+    },
+    output: "server",
+    adapter: node({
+        mode: "middleware"
+    })
+});

biome.json

@@ -0,0 +1,32 @@
+{
+    "$schema": "https://biomejs.dev/schemas/1.9.3/schema.json",
+    "files": {
+        "ignore": ["~/", "**/dist/**", ".github/**"],
+        "include": ["**/**", "server/**"]
+    },
+    "formatter": {
+        "indentStyle": "space",
+        "indentWidth": 4,
+        "lineWidth": 100,
+        "ignore": ["pnpm-lock.yaml", "package.json"]
+    },
+    "organizeImports": { "enabled": true },
+    "linter": { "enabled": false },
+    "javascript": {
+        "formatter": {
+            "trailingCommas": "none",
+            "quoteStyle": "double",
+            "semicolons": "always"
+        }
+    },
+    "json": {
+        "parser": {
+            "allowComments": true,
+            "allowTrailingCommas": true
+        },
+        "formatter": {
+            "indentStyle": "space",
+            "trailingCommas": "none"
+        }
+    }
+}

config.example.toml

@@ -0,0 +1,19 @@
+[marketplace]
+enabled = true # Turn on or off the marketplace entirely
+psk = "CHANGEME" # Change this to something more secure.
+level = 1
+
+[db]
+name = "database" # Your databsae name
+username = "username" # The username of your DB (SQLITE just ignores this)
+password = "password" # The password to your DB (SQLITE ignores this)
+postgres = false # Enable to use postgres over sqlite (recommended for large prod instances)
+
+[postgres] # Set the "domain" to either and ip address or a actual domain 
+domain = ""
+port = 5432
+
+[server.server]
+port = 7860
+wisp = true
+logging = true # Disable for the tons & tons of logs to go away (useful for debugging but otherwise eh)

docker-compose.build.yml

@@ -0,0 +1,21 @@
+services:
+  nebula:
+    image: ghcr.io/nebulaservices/nebula:latest
+    container_name: nebula
+    build: .
+    restart: unless-stopped
+    ports:
+      # HOST:CONTAINER (DO NOT CHANGE THE CONTAINER PORT, UNLESS EDITED IN THE config.toml FILE)
+      - 8080:8080
+    volumes:
+      - ./config.toml:/app/config.toml
+# Uncomment the the below stuff to use POSTGRES!
+#  db:
+#    image: postgres
+#    restart: unless-stopped
+#    environment:
+#      POSTGRES_PASSWORD: password #CHANGE THIS
+#      POSTGRES_USER: username
+#      POSTGRES_DB: db
+#    volumes:
+#      - ./db:/var/lib/postgresql/data

docker-compose.yml

@@ -0,0 +1,20 @@
+services:
+  nebula:
+    image: ghcr.io/nebulaservices/nebula:latest
+    container_name: nebula
+    restart: unless-stopped
+    ports:
+      # HOST:CONTAINER (DO NOT CHANGE THE CONTAINER PORT, UNLESS EDITED IN THE config.toml FILE)
+      - 8080:8080
+    volumes:
+      - ./config.toml:/app/config.toml 
+# Uncomment the the below stuff to use POSTGRES!
+#  db:
+#    image: postgres
+#    restart: unless-stopped
+#    environment:
+#      POSTGRES_PASSWORD: password #CHANGE THIS
+#      POSTGRES_USER: username
+#      POSTGRES_DB: db
+#    volumes:
+#      - ./db:/var/lib/postgresql/data

package.json

@@ -0,0 +1,67 @@
+{
+  "name": "nebula",
+  "type": "module",
+  "version": "9.0.2",
+  "private": true,
+  "scripts": {
+    "dev": "concurrently \"astro dev --host 0.0.0.0\" \"tsx --watch server/server.ts\"",
+    "start": "node server/server.js",
+    "build:server": "tsc -p server",
+    "build:client": "astro check && astro build",
+    "build": "concurrently \"npm:build:server\" \"npm:build:client\"",
+    "bstart": "npm run build && npm run start",
+    "preview": "astro preview",
+    "astro": "astro",
+    "format:code": "biome format . --write",
+    "format:imports": "biome check . --write",
+    "format": "concurrently -m 1 \"npm:format:code\" \"npm:format:imports\"",
+    "version": "changeset version"
+  },
+  "dependencies": {
+    "@astrojs/check": "^0.8.3",
+    "@astrojs/node": "^8.3.4",
+    "@astrojs/svelte": "^5.7.3",
+    "@astrojs/tailwind": "^5.1.2",
+    "@fastify/compress": "^8.0.1",
+    "@fastify/helmet": "^12.0.1",
+    "@fastify/middie": "^9.0.2",
+    "@fastify/multipart": "^9.0.1",
+    "@fastify/static": "^8.0.2",
+    "@iconify-json/ph": "^1.2.1",
+    "@mercuryworkshop/bare-mux": "^2.1.6",
+    "@mercuryworkshop/epoxy-transport": "2.1.13",
+    "@mercuryworkshop/libcurl-transport": "^1.3.12",
+    "@playform/compress": "^0.1.6",
+    "@svelte-drama/suspense": "0.5.1",
+    "@titaniumnetwork-dev/ultraviolet": "^3.2.10",
+    "@types/node": "^22.9.0",
+    "@types/sequelize": "^4.28.20",
+    "astro": "^4.16.10",
+    "astro-icon": "^1.1.2",
+    "chalk": "^5.3.0",
+    "concurrently": "^8.2.2",
+    "fastify": "^5.1.0",
+    "form-data": "^4.0.1",
+    "gradient-string": "^3.0.0",
+    "nanostores": "^0.10.3",
+    "ora": "^8.1.1",
+    "pg": "^8.13.1",
+    "pg-hstore": "^2.3.4",
+    "sequelize": "^6.37.5",
+    "smol-toml": "^1.3.0",
+    "sqlite3": "^5.1.7",
+    "svelte": "^4.2.19",
+    "svelte-french-toast": "^1.2.0",
+    "tailwindcss": "^3.4.14",
+    "typescript": "^5.6.3",
+    "vite-plugin-static-copy": "^1.0.6",
+    "wisp-server-node": "^1.1.7"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@changesets/cli": "^2.27.9",
+    "bufferutil": "^4.0.8",
+    "sharp": "^0.33.5",
+    "tsx": "^4.19.2"
+  }
+}

public/nebula.css

@@ -0,0 +1,19 @@
+:root {
+    --background-primary: #191724;
+    --background-lighter: #16121f;
+    --navbar-color: #26233a;
+    --navbar-height: 60px;
+    --navbar-text-color: #7967dd;
+    --navbar-link-color: #e0def4;
+    --navbar-link-hover-color: gray;
+    --navbar-font: "Roboto";
+    --input-text-color: #e0def4;
+    --input-placeholder-color: white;
+    --input-background-color: #1f1d2e;
+    --input-border-color: #eb6f92;
+    --input-border-size: 1.3px;
+    --navbar-logo-filter: none;
+    --dropdown-option-hover-color: #312a49;
+    --tab-color: var(--black);
+    --border-color: #16121f;
+}

public/sw.js

@@ -0,0 +1,65 @@
+importScripts("/uv/uv.bundle.js");
+importScripts("/uv/uv.config.js");
+importScripts("/workerware/workerware.js");
+importScripts(__uv$config.sw || "/uv/uv.sw.js");
+const uv = new UVServiceWorker();
+const ww = new WorkerWare({ debug: false });
+
+//me when Firefox (thanks vk6)
+if (navigator.userAgent.includes("Firefox")) {
+    Object.defineProperty(globalThis, "crossOriginIsolated", {
+        value: true,
+        writable: true
+    });
+}
+
+//where we handle our plugins!!!
+self.addEventListener("message", function (event) {
+    console.log(event.data);
+    uv.config.inject = [];
+    //loop over the required data (we don't verify here as types will take care of us :D)
+    event.data.forEach((data) => {
+        if (data.remove) {
+            if (data.type === "page") {
+                const idx = uv.config.inject.indexOf(data.host);
+                uv.config.inject.splice(idx, 1);
+            } else if (data.type === "serviceWorker") {
+                ww.deleteByName(data.name);
+            }
+        } else {
+            if (data.type === "page") {
+                uv.config.inject.push({
+                    host: data.host,
+                    html: data.html,
+                    injectTo: data.injectTo
+                });
+            } else if (data.type === "serviceWorker") {
+                const wwFunction = eval(data.function);
+                ww.use({
+                    function: wwFunction ? wwFunction : new Function(data.function),
+                    name: data.name,
+                    events: data.events
+                });
+            } else {
+                console.error("NO type exists for that. Only serviceWorker & page exist.");
+                return;
+            }
+        }
+    });
+});
+
+self.addEventListener("fetch", function (event) {
+    event.respondWith(
+        (async () => {
+            const wwRes = await ww.run(event)();
+            if (wwRes.includes(null)) {
+                return;
+            }
+            if (event.request.url.startsWith(location.origin + __uv$config.prefix)) {
+                return await uv.fetch(event);
+            } else {
+                return await fetch(event.request);
+            }
+        })()
+    );
+});

public/uv/uv.config.js

@@ -0,0 +1,30 @@
+self.__uv$config = {
+    prefix: "/~/uv/",
+    bare: "/bare/",
+    encodeUrl: function encode(str) {
+        if (!str) return str;
+        return encodeURIComponent(
+            str
+                .toString()
+                .split("")
+                .map((char, ind) => (ind % 2 ? String.fromCharCode(char.charCodeAt() ^ 3) : char))
+                .join("")
+        );
+    },
+    decodeUrl: function decode(str) {
+        if (!str) return str;
+        let [input, ...search] = str.split("?");
+
+        return (
+            decodeURIComponent(input)
+                .split("")
+                .map((char, ind) => (ind % 2 ? String.fromCharCode(char.charCodeAt(0) ^ 3) : char))
+                .join("") + (search.length ? "?" + search.join("?") : "")
+        );
+    },
+    handler: "/uv/uv.handler.js",
+    client: "/uv/uv.client.js",
+    bundle: "/uv/uv.bundle.js",
+    config: "/uv/uv.config.js",
+    sw: "/uv/uv.sw.js"
+};

public/workerware/workerware.js

@@ -0,0 +1,171 @@
+importScripts("/workerware/WWError.js");
+const dbg = console.log.bind(console, "[WorkerWare]");
+const time = console.time.bind(console, "[WorkerWare]");
+const timeEnd = console.timeEnd.bind(console, "[WorkerWare]");
+
+/*
+  OPTS:
+    debug - Enables debug logging.
+    randomNames - Generate random names for middlewares.
+    timing - Logs timing for each middleware.
+*/
+
+const defaultOpt = {
+    debug: false,
+    randomNames: false,
+    timing: false
+};
+
+const validEvents = [
+    "abortpayment",
+    "activate",
+    "backgroundfetchabort",
+    "backgroundfetchclick",
+    "backgroundfetchfail",
+    "backgroundfetchsuccess",
+    "canmakepayment",
+    "contentdelete",
+    "cookiechange",
+    "fetch",
+    "install",
+    "message",
+    "messageerror",
+    "notificationclick",
+    "notificationclose",
+    "paymentrequest",
+    "periodicsync",
+    "push",
+    "pushsubscriptionchange",
+    "sync"
+];
+
+class WorkerWare {
+    constructor(opt) {
+        this._opt = Object.assign({}, defaultOpt, opt);
+        this._middlewares = [];
+    }
+    info() {
+        return {
+            version: "0.1.0",
+            middlewares: this._middlewares,
+            options: this._opt
+        };
+    }
+    use(middleware) {
+        let validateMW = this.validateMiddleware(middleware);
+        if (validateMW.error) throw new WWError(validateMW.error);
+        // This means the middleware is an anonymous function, or the user is silly and named their function "function"
+        if (middleware.function.name == "function") middleware.name = crypto.randomUUID();
+        if (!middleware.name) middleware.name = middleware.function.name;
+        if (this._opt.randomNames) middleware.name = crypto.randomUUID();
+        if (this._opt.debug) dbg("Adding middleware:", middleware.name);
+        this._middlewares.push(middleware);
+    }
+    // Run all middlewares for the event type passed in.
+    run(event) {
+        const middlewares = this._middlewares;
+        const returnList = [];
+        let fn = async () => {
+            for (let i = 0; i < middlewares.length; i++) {
+                if (middlewares[i].events.includes(event.type)) {
+                    if (this._opt.timing) console.time(middlewares[i].name);
+                    // Add the configuration to the event object.
+                    event.workerware = {
+                        config: middlewares[i].configuration || {}
+                    };
+                    if (!middlewares[i].explicitCall) {
+                        let res = await middlewares[i].function(event);
+                        if (this._opt.timing) console.timeEnd(middlewares[i].name);
+                        returnList.push(res);
+                    }
+                }
+            }
+            return returnList;
+        };
+        return fn;
+    }
+    deleteByName(middlewareID) {
+        if (this._opt.debug) dbg("Deleting middleware:", middlewareID);
+        this._middlewares = this._middlewares.filter((mw) => mw.name !== middlewareID);
+    }
+    deleteByEvent(middlewareEvent) {
+        if (this._opt.debug) dbg("Deleting middleware by event:", middlewareEvent);
+        this._middlewares = this._middlewares.filter((mw) => !mw.events.includes(middlewareEvent));
+    }
+    get() {
+        return this._middlewares;
+    }
+    /*  
+    Run a single middleware by ID.
+    This assumes that the user knows what they're doing, and is running the middleware on an event that it's supposed to run on.
+  */
+    runMW(name, event) {
+        const middlewares = this._middlewares;
+        if (this._opt.debug) dbg("Running middleware:", name);
+        // if (middlewares.includes(name)) {
+        //   return middlewares[name](event);
+        // } else {
+        //   throw new WWError("Middleware not found!");
+        // }
+        let didCall = false;
+        for (let i = 0; i < middlewares.length; i++) {
+            if (middlewares[i].name == name) {
+                didCall = true;
+                event.workerware = {
+                    config: middlewares[i].configuration || {}
+                };
+                if (this._opt.timing) console.time(middlewares[i].name);
+                let call = middlewares[i].function(event);
+                if (this._opt.timing) console.timeEnd(middlewares[i].name);
+                return call;
+            }
+        }
+        if (!didCall) {
+            throw new WWError("Middleware not found!");
+        }
+    }
+    // type middlewareManifest = {
+    //     function: Function,
+    //     name?: string,
+    //     events: string[], // Should be a union of validEvents.
+    //     configuration?: Object // Optional configuration for the middleware.
+    // }
+    validateMiddleware(middleware) {
+        if (!middleware.function)
+            return {
+                error: "middleware.function is required"
+            };
+        if (typeof middleware.function !== "function")
+            return {
+                error: "middleware.function must be typeof function"
+            };
+        if (
+            typeof middleware.configuration !== "object" &&
+            middleware.configuration !== undefined
+        ) {
+            return {
+                error: "middleware.configuration must be typeof object"
+            };
+        }
+        if (!middleware.events)
+            return {
+                error: "middleware.events is required"
+            };
+        if (!Array.isArray(middleware.events))
+            return {
+                error: "middleware.events must be an array"
+            };
+        if (middleware.events.some((ev) => !validEvents.includes(ev)))
+            return {
+                error: "Invalid event type! Must be one of the following: " + validEvents.join(", ")
+            };
+        if (middleware.explicitCall && typeof middleware.explicitCall !== "boolean") {
+            return {
+                error: "middleware.explicitCall must be typeof boolean"
+            };
+        }
+        return {
+            error: undefined
+        };
+    }
+}

requirements.txt

@@ -0,0 +1 @@
+flask

server/config.ts

@@ -0,0 +1,73 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import chalk from "chalk";
+import { TomlPrimitive, parse } from "smol-toml";
+
+interface TomlData {
+    marketplace: {
+        enabled: boolean;
+        psk: String;
+    };
+    server: {
+        server: {
+            port: number;
+            wisp: boolean;
+            logging: boolean;
+        };
+    };
+    db: {
+        name: string;
+        username: string;
+        password: string;
+        postgres: boolean;
+    };
+    postgres: {
+        domain: string;
+        port: number;
+    };
+}
+
+interface Verify {
+    name: string;
+    typeOF: any;
+    type: any;
+}
+
+let doc = readFileSync(fileURLToPath(new URL("../config.toml", import.meta.url))).toString();
+const parsedDoc = parse(doc) as unknown as TomlData;
+
+function verify(t: Verify[]) {
+    for (let i: number = 0; i !== t.length; i++) {
+        if (typeof t[i].typeOF !== t[i].type) {
+            throw new Error(`Invalid structure: "${t[i].name}" should be a(n) ${t[i].type}`);
+        }
+    }
+}
+
+verify([
+    { name: "marketplace", typeOF: parsedDoc.marketplace, type: "object" },
+    { name: "marketplace.enabled", typeOF: parsedDoc.marketplace.enabled, type: "boolean" },
+    { name: "marketplace.psk", typeOF: parsedDoc.marketplace.psk, type: "string" },
+    { name: "server", typeOF: parsedDoc.server, type: "object" },
+    { name: "server.server", typeOF: parsedDoc.server.server, type: "object" },
+    { name: "server.server.port", typeOF: parsedDoc.server.server.port, type: "number" },
+    { name: "server.server.wisp", typeOF: parsedDoc.server.server.wisp, type: "boolean" },
+    { name: "server.server.logging", typeOF: parsedDoc.server.server.logging, type: "boolean" },
+    { name: "db", typeOF: parsedDoc.db, type: "object" },
+    { name: "db.name", typeOF: parsedDoc.db.name, type: "string" },
+    { name: "db.username", typeOF: parsedDoc.db.username, type: "string" },
+    { name: "db.password", typeOF: parsedDoc.db.password, type: "string" },
+    { name: "db.postgres", typeOF: parsedDoc.db.postgres, type: "boolean" },
+    { name: "postgres", typeOF: parsedDoc.postgres, type: "object" },
+    { name: "postgres.domain", typeOF: parsedDoc.postgres.domain, type: "string" },
+    { name: "postgres.port", typeOF: parsedDoc.postgres.port, type: "number" }
+]);
+
+if (parsedDoc.marketplace.psk === "CHANGEME") {
+    console.warn(chalk.yellow.bold('PSK should be changed from "CHANGEME"'));
+}
+if (parsedDoc.db.password === "password") {
+    console.warn(chalk.red.bold("You should change your DB password!!"));
+}
+
+export { TomlData, parsedDoc };

server/dbSetup.ts

@@ -0,0 +1,87 @@
+import { fileURLToPath } from "node:url";
+import chalk from "chalk";
+import ora from "ora";
+import { ModelStatic } from "sequelize";
+import { Catalog, CatalogModel } from "./marketplace.js";
+
+interface Items extends Omit<Catalog, "background_video" | "background_image"> {
+    background_video?: string;
+    background_image?: string;
+}
+
+async function installItems(db: ModelStatic<CatalogModel>, items: Items[]) {
+    items.forEach(async (item) => {
+        await db.create({
+            package_name: item.package_name,
+            title: item.title,
+            image: item.image,
+            author: item.author,
+            version: item.version,
+            description: item.description,
+            tags: item.tags,
+            payload: item.payload,
+            background_video: item.background_video,
+            background_image: item.background_image,
+            type: item.type
+        });
+    });
+}
+
+async function setupDB(db: ModelStatic<CatalogModel>) {
+    //We have some packages that need to be installed if they aren't.
+    const items: Items[] = [
+        {
+            package_name: "com.nebula.gruvbox",
+            title: "Gruvbox",
+            image: "gruvbox.jpeg",
+            author: "Nebula Services",
+            version: "1.0.0",
+            description: "The gruvbox theme",
+            tags: ["Theme", "Simple"],
+            payload: "gruvbox.css",
+            type: "theme"
+        },
+        {
+            package_name: "com.nebula.oled",
+            title: "Oled theme",
+            image: "oled.jpg",
+            author: "Nebula Services",
+            version: "1.0.0",
+            description: "A sleek & simple Oled theme for Nebula",
+            tags: ["Theme", "Simple", "Sleek"],
+            payload: "oled.css",
+            type: "theme"
+        },
+        {
+            package_name: "com.nebula.lightTheme",
+            title: "Light Theme",
+            image: "light.png",
+            author: "Nebula Services",
+            version: "1.0.0",
+            description: "A sleek light theme for Nebula",
+            tags: ["Theme", "Simple", "Light"],
+            payload: "light.css",
+            type: "theme"
+        },
+        {
+            package_name: "com.nebula.retro",
+            title: "Retro Theme",
+            image: "retro.png",
+            author: "Nebula Services",
+            version: "1.0.0",
+            description: "Give a retro look to Nebula",
+            tags: ["Theme", "Simple", "Dark", "Retro"],
+            payload: "retro.css",
+            type: "theme"
+        }
+        //To add plugins: plugin types consist of plugin-sw (workerware) & plugin-page (uv.config.inject)
+    ];
+    const dbItems = await db.findAll();
+    if (dbItems.length === 0) {
+        const spinner = ora(chalk.hex("#7967dd")("Performing DB setup...")).start();
+        await installItems(db, items);
+        spinner.succeed(chalk.hex("#eb6f92")("DB setup complete!"));
+    }
+}
+
+export { setupDB };

server/env.d.ts

@@ -0,0 +1 @@
+declare module "@rubynetwork/rammerhead/src/server/index.js";

server/marketplace.ts

@@ -0,0 +1,229 @@
+import { createWriteStream } from "node:fs";
+import { constants, access, mkdir } from "node:fs/promises";
+import { pipeline } from "node:stream/promises";
+import { fileURLToPath } from "node:url";
+import { FastifyInstance, FastifyRequest } from "fastify";
+import { DataTypes, InferAttributes, InferCreationAttributes, Model, Sequelize } from "sequelize";
+import { parsedDoc } from "./config.js";
+
+const db = new Sequelize(parsedDoc.db.name, parsedDoc.db.username, parsedDoc.db.password, {
+    host: parsedDoc.db.postgres ? `${parsedDoc.postgres.domain}` : "localhost",
+    port: parsedDoc.db.postgres ? parsedDoc.postgres.port : undefined,
+    dialect: parsedDoc.db.postgres ? "postgres" : "sqlite",
+    logging: parsedDoc.server.server.logging,
+    storage: "database.sqlite" //this is sqlite only
+});
+
+type CatalogType = "theme" | "plugin-page" | "plugin-sw";
+
+interface Catalog {
+    package_name: string;
+    title: string;
+    description: string;
+    author: string;
+    image: string;
+    tags: object;
+    version: string;
+    background_image: string;
+    background_video: string;
+    payload: string;
+    type: CatalogType;
+}
+
+interface CatalogModel
+    extends Catalog,
+        Model<InferAttributes<CatalogModel>, InferCreationAttributes<CatalogModel>> {}
+
+const catalogAssets = db.define<CatalogModel>("catalog_assets", {
+    package_name: { type: DataTypes.STRING, unique: true },
+    title: { type: DataTypes.TEXT },
+    description: { type: DataTypes.TEXT },
+    author: { type: DataTypes.TEXT },
+    image: { type: DataTypes.TEXT },
+    tags: { type: DataTypes.JSON, allowNull: true },
+    version: { type: DataTypes.TEXT },
+    background_image: { type: DataTypes.TEXT, allowNull: true },
+    background_video: { type: DataTypes.TEXT, allowNull: true },
+    payload: { type: DataTypes.TEXT },
+    type: { type: DataTypes.TEXT }
+});
+
+function marketplaceAPI(app: FastifyInstance) {
+    app.get("/api/catalog-stats/", (request, reply) => {
+        reply.send({
+            version: "1.0.0",
+            spec: "Nebula Services",
+            enabled: true
+        });
+    });
+
+    // This API returns a list of the assets in the database (SW plugins and themes).
+    // It also returns the number of pages in the database.
+    // It can take a `?page=x` argument to display a different page, with a limit of 20 assets per page.
+    type CatalogAssetsReq = FastifyRequest<{ Querystring: { page: string } }>;
+    app.get("/api/catalog-assets/", async (request: CatalogAssetsReq, reply) => {
+        try {
+            const { page } = request.query;
+            const pageNum: number = parseInt(page, 10) || 1;
+            if (pageNum < 1) {
+                reply.status(400).send({ error: "Page must be a positive number!" });
+            }
+            const offset = (pageNum - 1) * 20;
+            const totalItems = await catalogAssets.count();
+            const dbAssets = await catalogAssets.findAll({ offset: offset, limit: 20 });
+            const assets = dbAssets.reduce((acc, asset) => {
+                acc[asset.package_name] = {
+                    title: asset.title,
+                    description: asset.description,
+                    author: asset.author,
+                    image: asset.image,
+                    tags: asset.tags,
+                    version: asset.version,
+                    background_image: asset.background_image,
+                    background_video: asset.background_video,
+                    payload: asset.payload,
+                    type: asset.type
+                };
+                return acc;
+            }, {});
+            return reply.send({ assets, pages: Math.ceil(totalItems / 20) });
+        } catch (error) {
+            return reply.status(500).send({ error: "An error occured" });
+        }
+    });
+
+    type PackageReq = FastifyRequest<{ Params: { package: string } }>;
+    app.get("/api/packages/:package", async (request: PackageReq, reply) => {
+        try {
+            const packageRow = await catalogAssets.findOne({
+                where: { package_name: request.params.package }
+            });
+            if (!packageRow) return reply.status(404).send({ error: "Package not found!" });
+            const details = {
+                title: packageRow.get("title"),
+                description: packageRow.get("description"),
+                image: packageRow.get("image"),
+                author: packageRow.get("author"),
+                tags: packageRow.get("tags"),
+                version: packageRow.get("version"),
+                background_image: packageRow.get("background_image"),
+                background_video: packageRow.get("background_video"),
+                payload: packageRow.get("payload"),
+                type: packageRow.get("type")
+            };
+            reply.send(details);
+        } catch (error) {
+            reply.status(500).send({ error: "An unexpected error occured" });
+        }
+    });
+
+    type UploadReq = FastifyRequest<{ Headers: { psk: string; packagename: string } }>;
+    type CreateReq = FastifyRequest<{
+        Headers: { psk: string };
+        Body: {
+            uuid: string;
+            title: string;
+            image: string;
+            author: string;
+            version: string;
+            description: string;
+            tags: object | any;
+            payload: string;
+            background_video: string;
+            background_image: string;
+            type: CatalogType;
+        };
+    }>;
+    interface VerifyStatus {
+        status: number;
+        error?: Error;
+    }
+    async function verifyReq(
+        request: UploadReq | CreateReq,
+        upload: Boolean,
+        data: any
+    ): Promise<VerifyStatus> {
+        if (request.headers.psk !== parsedDoc.marketplace.psk) {
+            return { status: 403, error: new Error("PSK isn't correct!") };
+        } else if (upload && !request.headers.packagename) {
+            return { status: 500, error: new Error("No packagename defined!") };
+        } else if (upload && !data) {
+            return { status: 400, error: new Error("No file uploaded!") };
+        } else {
+            return { status: 200 };
+        }
+    }
+
+    app.post("/api/upload-asset", async (request: UploadReq, reply) => {
+        const data = await request.file();
+        const verify: VerifyStatus = await verifyReq(request, true, data);
+        if (verify.error !== undefined) {
+            reply.status(verify.status).send({ status: verify.error.message });
+        } else {
+            try {
+                await pipeline(
+                    data.file,
+                    createWriteStream(
+                        fileURLToPath(
+                            new URL(
+                                `../database_assets/${request.headers.packagename}/${data.filename}`,
+                                import.meta.url
+                            )
+                        )
+                    )
+                );
+            } catch (error) {
+                return reply.status(500).send({
+                    status: `File couldn't be uploaded! (Package most likely doesn't exist)`
+                });
+            }
+            return reply.status(verify.status).send({ status: "File uploaded successfully!" });
+        }
+    });
+
+    app.post("/api/create-package", async (request: CreateReq, reply) => {
+        const verify: VerifyStatus = await verifyReq(request, false, undefined);
+        if (verify.error !== undefined) {
+            reply.status(verify.status).send({ status: verify.error.message });
+        } else {
+            const body: Catalog = {
+                package_name: request.body.uuid,
+                title: request.body.title,
+                image: request.body.image,
+                author: request.body.author,
+                version: request.body.version,
+                description: request.body.description,
+                tags: request.body.tags,
+                payload: request.body.payload,
+                background_video: request.body.background_video,
+                background_image: request.body.background_image,
+                type: request.body.type as CatalogType
+            };
+            await catalogAssets.create({
+                package_name: body.package_name,
+                title: body.title,
+                image: body.image,
+                author: body.author,
+                version: body.version,
+                description: body.description,
+                tags: body.tags,
+                payload: body.payload,
+                background_video: body.background_video,
+                background_image: body.background_image,
+                type: body.type
+            });
+            const assets = fileURLToPath(new URL("../database_assets", import.meta.url));
+            try {
+                await access(`${assets}/${body.package_name}/`, constants.F_OK);
+                return reply.status(500).send({ status: "Package already exists!" });
+            } catch (err) {
+                await mkdir(`${assets}/${body.package_name}/`);
+                return reply
+                    .status(verify.status)
+                    .send({ status: "Package created successfully!" });
+            }
+        }
+    });
+}
+
+export { marketplaceAPI, db, catalogAssets, Catalog, CatalogModel };

server/server.ts

@@ -0,0 +1,93 @@
+import { createWriteStream } from "node:fs";
+import { constants, access, mkdir } from "node:fs/promises";
+import { pipeline } from "node:stream/promises";
+import { fileURLToPath } from "node:url";
+import fastifyCompress from "@fastify/compress";
+import fastifyHelmet from "@fastify/helmet";
+import fastifyMiddie from "@fastify/middie";
+import fastifyMultipart from "@fastify/multipart";
+import fastifyStatic from "@fastify/static";
+import chalk from "chalk";
+import Fastify, { FastifyReply, FastifyRequest } from "fastify";
+import gradient from "gradient-string";
+//@ts-ignore WHY would I want this typechecked AT ALL
+import { handler as ssrHandler } from "../dist/server/entry.mjs";
+import { parsedDoc } from "./config.js";
+import { setupDB } from "./dbSetup.js";
+import { catalogAssets, marketplaceAPI } from "./marketplace.js";
+import { serverFactory } from "./serverFactory.js";
+
+const app = Fastify({
+    logger: parsedDoc.server.server.logging,
+    ignoreDuplicateSlashes: true,
+    ignoreTrailingSlash: true,
+    serverFactory: serverFactory
+});
+
+await app.register(fastifyCompress, {
+    encodings: ["br", "gzip", "deflate"]
+});
+
+await app.register(fastifyMultipart, {
+  limits: {
+    fileSize: 25 * 1024 * 1024,
+    parts: Infinity
+  },
+});
+
+await app.register(fastifyHelmet, {
+    xFrameOptions: false,
+    crossOriginEmbedderPolicy: true,
+    crossOriginOpenerPolicy: true,
+    contentSecurityPolicy: false
+});
+
+await app.register(fastifyStatic, {
+    root: fileURLToPath(new URL("../dist/client", import.meta.url))
+});
+
+//Our marketplace API. Not middleware as I don't want to deal with that LOL. Just a function that passes our app to it.
+if (parsedDoc.marketplace.enabled) {
+    await app.register(fastifyStatic, {
+        root: fileURLToPath(new URL("../database_assets", import.meta.url)),
+        prefix: "/packages/",
+        decorateReply: false
+    });
+    marketplaceAPI(app);
+}
+
+await app.register(fastifyMiddie);
+
+app.use(ssrHandler);
+
+const port: number =
+    parseInt(process.env.PORT as string) || parsedDoc.server.server.port || parseInt("8080");
+const titleText = ` 
+ _   _      _           _         ____                  _               
+| \\ | | ___| |__  _   _| | __ _  / ___|  ___ _ ____   _(_) ___ ___  ___ 
+|  \\| |/ _ \\ '_ \\| | | | |/ _' | \\___ \\ / _ \\ '__\\ \\ / / |/ __/ _ \\/ __|
+| |\\  |  __/ |_) | |_| | | (_| |  ___) |  __/ |   \\ V /| | (_|  __/\\__ \\
+|_| \\_|\\___|_.__/ \\__,_|_|\\__,_| |____/ \\___|_|    \\_/ |_|\\___\\___||___/
+`;
+const titleColors = {
+    purple: "#7967dd",
+    pink: "#eb6f92"
+};
+
+console.log(gradient(Object.values(titleColors)).multiline(titleText as string));
+app.listen({ port: port, host: "0.0.0.0" }).then(async () => {
+    console.log(
+        chalk.hex("#7967dd")(
+            `Server listening on ${chalk.hex("#eb6f92").bold("http://localhost:" + port + "/")}`
+        )
+    );
+    console.log(
+        chalk.hex("#7967dd")(
+            `Server also listening on ${chalk.hex("#eb6f92").bold("http://0.0.0.0:" + port + "/")}`
+        )
+    );
+    if (parsedDoc.marketplace.enabled) {
+        await catalogAssets.sync();
+        await setupDB(catalogAssets);
+    }
+});

server/serverFactory.ts

@@ -0,0 +1,29 @@
+import { createServer } from "node:http";
+import { FastifyServerFactory, FastifyServerFactoryHandler, RawServerDefault } from "fastify";
+import wisp from "wisp-server-node";
+import { LOG_LEVEL, WispOptions } from "wisp-server-node/dist/Types.js";
+import { parsedDoc } from "./config.js";
+
+const wispOptions: WispOptions = {
+    logLevel: parsedDoc.server.server.logging ? LOG_LEVEL.DEBUG : LOG_LEVEL.NONE,
+    pingInterval: 30
+};
+
+const serverFactory: FastifyServerFactory = (
+    handler: FastifyServerFactoryHandler
+): RawServerDefault => {
+    const httpServer = createServer();
+    httpServer.on("request", (req, res) => {
+        handler(req, res);
+    });
+    httpServer.on("upgrade", (req, socket, head) => {
+        if (parsedDoc.server.server.wisp) {
+            if (req.url?.endsWith("/wisp/")) {
+                wisp.routeRequest(req, socket as any, head, wispOptions);
+            }
+        }
+    });
+    return httpServer;
+};
+
+export { serverFactory };

server/tsconfig.json

@@ -0,0 +1,11 @@
+{
+    "compilerOptions": {
+        "target": "ES2020",
+        "module": "ESNext",
+        "moduleResolution": "bundler",
+        "noEmit": false,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "paths": {}
+    }
+}

src/components/Card.astro

@@ -0,0 +1,61 @@
+---
+interface Props {
+    title: string;
+    body: string;
+    href: string;
+}
+
+const { href, title, body } = Astro.props;
+---
+
+<li class="link-card">
+	<a href={href}>
+		<h2>
+			{title}
+			<span>&rarr;</span>
+		</h2>
+		<p>
+			{body}
+		</p>
+	</a>
+</li>
+<style>
+	.link-card {
+		list-style: none;
+		display: flex;
+		padding: 1px;
+		background-color: #23262d;
+		background-image: none;
+		background-size: 400%;
+		border-radius: 7px;
+		background-position: 100%;
+		transition: background-position 0.6s cubic-bezier(0.22, 1, 0.36, 1);
+		box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.1);
+	}
+	.link-card > a {
+		width: 100%;
+		text-decoration: none;
+		line-height: 1.4;
+		padding: calc(1.5rem - 1px);
+		border-radius: 8px;
+		color: white;
+		background-color: #23262d;
+		opacity: 0.8;
+	}
+	h2 {
+		margin: 0;
+		font-size: 1.25rem;
+		transition: color 0.6s cubic-bezier(0.22, 1, 0.36, 1);
+	}
+	p {
+		margin-top: 0.5rem;
+		margin-bottom: 0;
+	}
+	.link-card:is(:hover, :focus-within) {
+		background-position: 0;
+		background-image: var(--accent-gradient);
+	}
+	.link-card:is(:hover, :focus-within) h2 {
+		color: rgb(var(--accent-light));
+	}
+</style>

src/components/Header.astro

@@ -0,0 +1,119 @@
+---
+import { MARKETPLACE_ENABLED } from "astro:env/client";
+import { Icon } from "astro-icon/components";
+import { getLangFromUrl, useTranslations } from "../i18n/utils";
+import { isMobileNavOpen } from "../store.js";
+import HeaderButton from "./HeaderButton.astro";
+import Logo from "./Logo.astro";
+const lang = getLangFromUrl(Astro.url);
+const t = useTranslations(lang);
+---
+
+<div
+  id="navbar"
+  class="flex h-16 flex-row items-center justify-end border-b-2 border-border-color bg-navbar-color px-4 z-30 relative"
+>
+  <div class="w-1/8">
+    {/* Typical desktop menu */}
+    <div class="relative flex-row hidden lg:flex">
+      <HeaderButton text={t("header.home")} route={`/${lang}/`}>
+        <Icon
+          name="ph:house-bold"
+          class="h-6 w-6 text-text-color transition duration-500 group-hover:text-text-hover-color md:h-6 md:w-6"
+        />
+      </HeaderButton>
+      <HeaderButton text={t("header.games")} route={`/${lang}/games/`}>
+        <Icon
+          name="ph:cube"
+          class="h-6 w-6 text-text-color transition duration-500 group-hover:text-text-hover-color md:h-6 md:w-6"
+        />
+        {
+          /* Astro won't let us pass the icon as a prop so it's going into the outlet here. */
+        }
+      </HeaderButton>
+      <HeaderButton
+        text={t("header.settings")}
+        route={`/${lang}/settings/appearance`}
+      >
+        <Icon
+          name="ph:wrench-fill"
+          class="h-6 w-6 text-text-color transition duration-500 group-hover:text-text-hover-color md:h-6 md:w-6"
+        />
+      </HeaderButton>
+      {MARKETPLACE_ENABLED &&
+        <HeaderButton text={t("header.catalog")} route={`/${lang}/catalog/1`}>
+            <Icon
+                name="ph:shopping-bag-open-fill"
+                class="h-6 w-6 text-text-color transition duration-500 group-hover:text-text-hover-color md:h-6 md:w-6"
+             />
+        </HeaderButton>
+      }
+      <HeaderButton text={t("header.morelinks")}>
+        <Icon
+          name="ph:link-bold"
+          class="h-6 w-6 text-text-color transition duration-500 group-hover:text-text-hover-color md:h-6 md:w-6"
+        />
+      </HeaderButton>
+    </div>
+    {/* Mobile hamburger menu */}
+    <div class="flex lg:hidden" id="mobileNavTrigger" transition:persist>
+      <Icon
+        name="ph:text-align-justify-bold"
+        class="h-9 w-9 text-text-color"
+        id="hamburger_menu"
+      />
+      <Icon
+        name="ph:caret-right-bold"
+        class="h-9 w-9 text-text-color hidden"
+        id="right_caret"
+      />
+    </div>
+  </div>
+</div>
+<script>
+  import { isMobileNavOpen } from "../store.js";
+  let isMobileNavOpenLocal = true;
+  const right_caret = document.getElementById("right_caret");
+  const hamburger_menu = document.getElementById("hamburger_menu");
+  const mobileNavTrigger = document.getElementById("mobileNavTrigger");
+  // Create a copy of the nano store so we can make this a toggle
+
+  // Set the store to true when the button is clicked
+  function openDialog() {
+    if (isMobileNavOpenLocal == false) {
+      isMobileNavOpen.set(true);
+      if (hamburger_menu && right_caret) {
+        hamburger_menu.style.display = "none";
+        right_caret.style.display = "block";
+      }
+    } else {
+      isMobileNavOpen.set(false);
+      if (hamburger_menu && right_caret) {
+        hamburger_menu.style.display = "block";
+        right_caret.style.display = "none";
+      }
+    }
+  }
+
+  isMobileNavOpen.subscribe((open) => {
+    if (open) {
+      isMobileNavOpenLocal = true;
+      if (hamburger_menu && right_caret) {
+        hamburger_menu.style.display = "none";
+        right_caret.style.display = "block";
+      }
+    } else {
+      isMobileNavOpenLocal = false;
+      if (hamburger_menu && right_caret) {
+        hamburger_menu.style.display = "block";
+        right_caret.style.display = "none";
+      }
+    }
+  });
+
+  // Add an event listener to the button
+
+  if (mobileNavTrigger) {
+    mobileNavTrigger.addEventListener("click", openDialog);
+  }
+</script>

src/components/HeaderButton.astro

@@ -0,0 +1,16 @@
+---
+const { text, route } = Astro.props;
+---
+
+<a
+  class="group flex w-full flex-row items-center justify-center border-t-2 border-solid border-navbar-text-color p-4 lg:border-none h-1/3 lg:h-fit"
+  id="header_anchor"
+  href={route}
+>
+  <slot />
+  <span
+    class="font-roboto pl-2 text-center text-3xl font-bold text-text-color roboto transition duration-500 group-hover:text-text-hover-color lg:text-xl text-nowrap"
+  >
+    {text}
+  </span>
+</a>