⭐ feat(infra): Update infra and add support for teams to SST (#186)

## Description
- [x] Adds support for AWS SSO, which makes us (the team) able to use
SST and update the components independently
- [x] Splits the webpage into the landing page (Qwik), and Astro (the
console) in charge of playing. This allows us to pass in Environment
Variables to the console
- ~Migrates the docs from Nuxt to Nextjs, and connects them to SST. This
allows us to use Fumadocs _citation needed_ that's much more beautiful,
and supports OpenApi~
- Cloudflare pages with github integration is not working on our new CF
account. So we will have to push the pages deployment manually with
Github actions
- [x] Moves the current set up from my personal CF and AWS accounts to
dedicated Nestri accounts -

## Related Issues
<!-- List any related issues (e.g., "Closes #123", "Fixes #456") -->

## Type of Change

- [ ] Bug fix (non-breaking change)
- [x] New feature (non-breaking change)
- [ ] Breaking change (fix or feature that changes existing
functionality)
- [x] Documentation update
- [ ] Other (please describe):

## Checklist

- [x] I have updated relevant documentation
- [x] My code follows the project's coding style
- [x] My changes generate no new warnings/errors

## Notes for Reviewers
<!-- Point out areas you'd like reviewers to focus on, questions you
have, or decisions that need discussion -->
Please approve my PR 🥹


## Screenshots/Demo
<!-- If applicable, add screenshots or a GIF demo of your changes
(especially for UI changes) -->

## Additional Context
<!-- Add any other context about the pull request here -->

packages/core/src:old/instance/index.ts

@@ -0,0 +1,83 @@
+import { z } from "zod"
+import { fn } from "../utils";
+import { Common } from "../common";
+import { Examples } from "../examples";
+import databaseClient from "../database"
+import { id as createID } from "@instantdb/admin";
+import { groupBy, map, pipe, values } from "remeda"
+
+export module Instances {
+    export const Info = z
+        .object({
+            id: z.string().openapi({
+                description: Common.IdDescription,
+                example: Examples.Instance.id,
+            }),
+            hostname: z.string().openapi({
+                description: "The container's hostname",
+                example: Examples.Instance.hostname,
+            }),
+            createdAt: z.string().or(z.number()).openapi({
+                description: "The time this instances was registered on the network",
+                example: Examples.Instance.createdAt,
+            }),
+            lastActive: z.string().or(z.number()).optional().openapi({
+                description: "The time this instance was last seen on the network",
+                example: Examples.Instance.lastActive,
+            })
+        })
+        .openapi({
+            ref: "Instance",
+            description: "Represents a running container that is connected to the Nestri network..",
+            example: Examples.Instance,
+        });
+
+    export type Info = z.infer<typeof Info>;
+    export const create = fn(z.object({ hostname: z.string(), teamID: z.string() }), async (input) => {
+        const id = createID()
+        const now = new Date().toISOString()
+        const db = databaseClient()
+        await db.transact(
+            db.tx.instances[id]!.update({
+                hostname: input.hostname,
+                createdAt: now,
+            }).link({ owners: input.teamID })
+        )
+
+        return "ok"
+    })
+
+    export const fromTeamID = fn(z.string(), async (teamID) => {
+        const db = databaseClient()
+
+        const query = {
+            instances: {
+                $: {
+                    where: {
+                        owners: teamID
+                    }
+                }
+            }
+        }
+
+        const res = await db.query(query)
+        const data = res.instances
+
+        if (data && data.length > 0) {
+            const result = pipe(
+                data,
+                groupBy(x => x.id),
+                values(),
+                map((group): Info => ({
+                    id: group[0].id,
+                    lastActive: group[0].lastActive,
+                    hostname: group[0].hostname,
+                    createdAt: group[0].createdAt
+                }))
+            )
+            return result
+        }
+
+        return null
+    })
+}