first commit!

.gitignore

···
 
 # vercel
 .vercel
+.turbo
 
 **/*.trace
 **/*.zip
···
 **/*.tgz
 **/*.log
 package-lock.json
-**/*.bun
+**/*.bun

apps/aqua/.drizzle/0000_same_maelstrom.sql

···
+CREATE TABLE `auth_session` (
+	`key` text PRIMARY KEY NOT NULL,
+	`session` text NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE `auth_state` (
+	`key` text PRIMARY KEY NOT NULL,
+	`state` text NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE `status` (
+	`uri` text PRIMARY KEY NOT NULL,
+	`authorDid` text NOT NULL,
+	`status` text NOT NULL,
+	`createdAt` text NOT NULL,
+	`indexedAt` text NOT NULL
+);

apps/aqua/.drizzle/meta/0000_snapshot.json

···
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "417cce08-b23b-4a9f-ad7e-e96215e0fb38",
+  "prevId": "00000000-0000-0000-0000-000000000000",
+  "tables": {
+    "auth_session": {
+      "name": "auth_session",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "session": {
+          "name": "session",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "auth_state": {
+      "name": "auth_state",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "state": {
+          "name": "state",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "status": {
+      "name": "status",
+      "columns": {
+        "uri": {
+          "name": "uri",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "authorDid": {
+          "name": "authorDid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "indexedAt": {
+          "name": "indexedAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}

apps/aqua/.drizzle/meta/_journal.json

···
+{
+  "version": "7",
+  "dialect": "sqlite",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "6",
+      "when": 1729467718506,
+      "tag": "0000_same_maelstrom",
+      "breakpoints": true
+    }
+  ]
+}

apps/aqua/.env

···
+PRIVATE_KEY_1={"kty":"EC","d":"8rx-D2vaik7FgRUaMeK_M8yZQ57J5NFs4MP6300_gek","use":"sig","crv":"P-256","kid":"44J2ZYr_4O3wp1B8GSRPvHMb7Cf506Nss3ISOplRx9I","x":"f9RLs9sqKyL38dPKsQaX-P_qTHVnNRCXuzkjbPvh7Ls","y":"ZnH5GuTAl5TTb-hZzsVgf1kUl4OB6qCS0PmM4_SPXvw","alg":"ES256"}
+PRIVATE_KEY_2={"kty":"EC","d":"5Rk8UuCz-chUX_OZ4WgB7lb3OELn-xlGEedk4P-qY_M","use":"sig","crv":"P-256","kid":"kzDrzoJdNtK3bfTiuJYQZSk_Z7nsZqEpzqYSqHVBN_Q","x":"WuMNQ3slMhmvUJze-q4pxmC_Xqu5MkpkD3eSh1dPDBs","y":"0CS96lObk2UWnRbbrhQQDbduyZ_A4zKZtwSQTfqVkcU","alg":"ES256"}
+PRIVATE_KEY_3={"kty":"EC","d":"GvpzAoGaHCG3OFe8qqi8FRs3WShGvS8OAOhjcN2vyuQ","use":"sig","crv":"P-256","kid":"y0HFLgCqOSwfbRJdO48dM8prLrLrT-qxNs_UrdvrbNQ","x":"VJ13t663tWZa67wUNQw26iU9iatIg4ZIklNKOrqMiYw","y":"Fqyc7qiOfwaYDXO259G8T66Wg2Kf_WLEjyi0ZenX2pI","alg":"ES256"}
+NODE_ENV=development # Options: development, production
+PORT=3000           # The port your server will listen on
+HOST=localhost       # Hostname for the server
+PUBLIC_URL=          # Set when deployed publicly, e.g. "https://mysite.com". Informs OAuth client id.
+DB_PATH=:memory:     # The SQLite database path. Leave as ":memory:" to use a temporary in-memory database.
+# Secrets
+# Must set this in production. May be generated with `openssl rand -base64 33`=undefined
+# COOKIE_SECRET=""

apps/aqua/db/schema.ts

···
+import { defineConfig } from "drizzle-kit";
+import { sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+export default defineConfig({
+  dialect: "sqlite", // 'mysql' | 'postgresql' | 'sqlite' | 'turso'
+  schema: "./src/db/schema.ts",
+});
+
+export type DatabaseSchema = {
+  status: Status;
+  auth_session: AuthSession;
+  auth_state: AuthState;
+};
+
+export type Status = {
+  uri: string;
+  authorDid: string;
+  status: string;
+  createdAt: string;
+  indexedAt: string;
+};
+
+export type AuthSession = {
+  key: string;
+  session: AuthSessionJson;
+};
+
+export type AuthState = {
+  key: string;
+  state: AuthStateJson;
+};
+
+type AuthStateJson = string;
+
+type AuthSessionJson = string;
+
+// Tables
+
+export const status = sqliteTable("status", {
+  uri: text().primaryKey(),
+  authorDid: text().notNull(),
+  status: text().notNull(),
+  createdAt: text().notNull(),
+  indexedAt: text().notNull(),
+});
+
+export const authSession = sqliteTable("auth_session", {
+  key: text().primaryKey(),
+  session: text().notNull(),
+});
+
+export const authState = sqliteTable("auth_state", {
+  key: text().primaryKey(),
+  state: text().notNull(),
+});

apps/aqua/drizzle.config.ts

···
+import { defineConfig } from "drizzle-kit";
+import process from "node:process";
+
+export default defineConfig({
+  dialect: "sqlite",
+  schema: "./db/schema.ts",
+  out: "./.drizzle",
+  casing: "snake_case",
+  dbCredentials: {
+    url: process.env.DATABASE_URL ?? "./db.sqlite",
+  },
+});

apps/aqua/package.json

···
+{
+  "name": "@teal/aqua",
+  "type": "module",
+  "version": "1.0.50",
+  "main": "index.ts",
+  "packageManager": "bun@1.0.0+",
+  "scripts": {
+    "dev": "tsx watch --clear-screen=false src/index.ts | pino-pretty",
+    "bun:dev": "bun run src/index.ts | pino-pretty",
+    "build": "tsup",
+    "start": "node dist/index.js",
+    "lexgen": "lex gen-server ./src/lexicon ./lexicons/*",
+    "clean": "rimraf dist coverage",
+    "check-types": "tsc --noEmit",
+    "db:migrate": "drizzle-kit migrate",
+    "db:seed": "drizzle-kit seed",
+    "db:studio": "drizzle-kit studio"
+  },
+  "dependencies": {
+    "@atproto/api": "^0.13.14",
+    "@atproto/common": "^0.4.4",
+    "@atproto/identity": "^0.4.2",
+    "@atproto/lexicon": "^0.4.2",
+    "@atproto/oauth-client-node": "^0.1.4",
+    "@atproto/sync": "^0.1.4",
+    "@atproto/syntax": "^0.3.0",
+    "@atproto/xrpc-server": "^0.6.4",
+    "@hono/node-server": "^1.13.4",
+    "@libsql/client": "^0.14.0",
+    "dotenv": "^16.4.5",
+    "drizzle-orm": "^0.35.3",
+    "envalid": "^8.0.0",
+    "hono": "^4.6.8",
+    "jose": "^5.9.6",
+    "pino": "^9.5.0",
+    "turbo": "^2.2.3",
+    "uhtml": "^4.5.11"
+  },
+  "devDependencies": {
+    "@teal/tsconfig": "*",
+    "@atproto/lex-cli": "^0.4.1",
+    "@types/node": "^20.17.5",
+    "drizzle-kit": "^0.26.2",
+    "pino-pretty": "^11.3.0",
+    "rimraf": "^6.0.1",
+    "tsup": "^8.3.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.6.3"
+  },
+  "tsup": {
+    "entry": [
+      "src",
+      "!src/**/__tests__/**",
+      "!src/**/*.test.*"
+    ],
+    "splitting": false,
+    "sourcemap": true,
+    "clean": true
+  }
+}

apps/aqua/scripts/generateJWKS.ts

···
+import { generateKeyPair, exportJWK } from "jose";
+import { randomBytes } from "crypto";
+
+// Function to create JWKS and append to .env file
+async function createJWKS() {
+  const jwks: any = { keys: [] };
+
+  for (let i = 0; i < 3; i++) {
+    // Generate a new key pair
+    // const alg = "ES256";
+    // const { publicKey, privateKey } = await generateKeyPair(alg, {
+    //   extractable: true,
+    // });
+    // // Export the key pair as a JWK
+    // const jwk = await exportJWK(privateKey);
+    // jwk.kid = randomBytes(16).toString("hex");
+    // jwk.alg = alg;
+    // jwks.keys.push(jwk);
+
+    // TODO: replace this ASAP if in prod
+    let res = await fetch(
+      "https://mkjwk.org/jwk/ec?alg=ES256&use=sig&gen=sha256&crv=P-256",
+    );
+    let jwk_res = await res.json();
+    let jwk = jwk_res.jwk;
+    console.log("PRIVATE_KEY_" + (i + 1) + "=" + JSON.stringify(jwk));
+  }
+}
+
+// Execute the function
+createJWKS().catch(console.error);

apps/aqua/src/auth/client.ts

···
+import { NodeOAuthClient } from "@atproto/oauth-client-node";
+import type { Database } from "@/db";
+import { env } from "@/lib/env";
+import { SessionStore, StateStore } from "./storage";
+
+export const createClient = async (db: Database) => {
+  const publicUrl = env.PUBLIC_URL;
+  const url = publicUrl || `http://127.0.0.1:${env.PORT}`;
+  const enc = encodeURIComponent;
+  return new NodeOAuthClient({
+    clientMetadata: {
+      client_name: "Teal",
+      client_id: publicUrl
+        ? `${url}/client-metadata.json`
+        : `http://localhost?redirect_uri=${enc(`${url}/oauth/callback`)}&scope=${enc("atproto transition:generic")}`,
+      client_uri: url,
+      redirect_uris: [`${url}/oauth/callback`],
+      scope: "atproto transition:generic",
+      grant_types: ["authorization_code", "refresh_token"],
+      response_types: ["code"],
+      application_type: "web",
+      token_endpoint_auth_method: "none",
+      dpop_bound_access_tokens: true,
+    },
+    stateStore: new StateStore(db),
+    sessionStore: new SessionStore(db),
+  });
+};

apps/aqua/src/auth/router.ts

···
+import { createClient } from "./client";
+import { db } from "@/db";
+import { EnvWithCtx, TealContext } from "@/ctx";
+import { authSession } from "../../db/schema";
+import { Hono } from "hono";
+
+interface LoginBody {
+  handle?: string;
+}
+
+export const login = async (c: TealContext) => {
+  let body: LoginBody = await c.req.json();
+  // Initiate the OAuth flow
+  const auth = await createClient(db);
+  if (!body) return Response.json({ error: "Could not parse body" });
+  // handle is the handle of the user
+  if (!body.handle && body.handle === undefined)
+    return Response.json({ error: "Handle is required" });
+  try {
+    const url = await auth.authorize(body.handle, {
+      scope: "atproto transition:generic",
+      state: crypto.randomUUID(),
+    });
+    return Response.json({ redirect_to: url });
+  } catch (e) {
+    console.error(e);
+    return Response.json({ error: "Could not authorize user" });
+  }
+};
+
+export async function loginGet(handle: string) {
+  // Initiate the OAuth flow
+  const auth = await createClient(db);
+  try {
+    const url = await auth.authorize("natalie.sh", {
+      scope: "atproto transition:generic",
+    });
+    return Response.redirect(url);
+  } catch (e) {
+    console.error(e);
+    return Response.json({ error: "Could not authorize user" });
+  }
+}
+
+export async function callback(c: TealContext) {
+  // Initiate the OAuth flow
+  const auth = await createClient(db);
+  try {
+    const honoParams = c.req.query();
+    console.log("params", honoParams);
+    const params = new URLSearchParams(honoParams);
+    const cb = await auth.callback(params);
+
+    // generate a session key (random)
+
+    const sessionKey = crypto.randomUUID();
+
+    // insert in session table, return data from cb
+
+    c.var.db.insert(authSession).values({
+      key: sessionKey,
+      session: JSON.stringify(cb.session),
+    });
+
+    return Response.json(cb);
+  } catch (e) {
+    console.error(e);
+    return Response.json({ error: "Could not authorize user" });
+  }
+}
+
+const app = new Hono<EnvWithCtx>();
+
+app.get("/login", async (c) => loginGet("natalie.sh"));
+
+app.post("/login", async (c) => login(c));
+
+app.get("/callback", async (c) => callback(c));
+
+export const getAuthRouter = () => {
+  return app;
+};

apps/aqua/src/auth/storage.ts

···
+import type {
+  NodeSavedSession,
+  NodeSavedSessionStore,
+  NodeSavedState,
+  NodeSavedStateStore,
+} from "@atproto/oauth-client-node";
+import type { Database } from "@/db";
+import { authSession, authState } from "../../db/schema";
+import { eq } from "drizzle-orm";
+
+export class StateStore implements NodeSavedStateStore {
+  constructor(private db: Database) {}
+  async get(key: string): Promise<NodeSavedState | undefined> {
+    const result = await this.db
+      .select()
+      .from(authState)
+      .where(eq(authState.key, key))
+      .limit(1)
+      .execute();
+    // .selectFrom("auth_state")
+    // .selectAll()
+    // .where("key", "=", key)
+    // .executeTakeFirst();
+    console.log("getting state", key, result);
+    if (!result[0]) return;
+    return JSON.parse(result[0].state) as NodeSavedState;
+  }
+  async set(key: string, val: NodeSavedState) {
+    const state = JSON.stringify(val);
+    console.log("inserting state", key, state);
+    await this.db
+      .insert(authState)
+      .values({ key, state })
+      .onConflictDoUpdate({
+        set: { state: state },
+        target: authState.key,
+      })
+      .execute();
+    // .insertInto("auth_state")
+    // .values({ key, state })
+    // .onConflict((oc) => oc.doUpdateSet({ state }))
+    // .execute();
+  }
+  async del(key: string) {
+    await this.db.delete(authState).where(eq(authState.key, key)).execute();
+    //.deleteFrom("auth_state").where("key", "=", key).execute();
+  }
+}
+
+export class SessionStore implements NodeSavedSessionStore {
+  constructor(private db: Database) {}
+  async get(key: string): Promise<NodeSavedSession | undefined> {
+    const result = await this.db
+      .select()
+      .from(authSession)
+      .where(eq(authSession.key, key))
+      .limit(1)
+      .all();
+    // .selectFrom("auth_session")
+    // .selectAll()
+    // .where("key", "=", key)
+    // .executeTakeFirst();
+    if (!result[0]) return;
+    return JSON.parse(result[0].session) as NodeSavedSession;
+  }
+  async set(key: string, val: NodeSavedSession) {
+    const session = JSON.stringify(val);
+    await this.db
+      .insert(authSession)
+      .values({ key, session })
+      .onConflictDoUpdate({
+        set: { session: session },
+        target: authSession.key,
+      })
+      .execute();
+    // .insertInto("auth_session")
+    // .values({ key, session })
+    // .onConflict((oc) => oc.doUpdateSet({ session }))
+    // .execute();
+  }
+  async del(key: string) {
+    await this.db.delete(authSession).where(eq(authSession.key, key)).execute();
+    //.deleteFrom("auth_session").where("key", "=", key).execute();
+  }
+}

apps/aqua/src/ctx.ts

···
+import { NodeOAuthClient } from "@atproto/oauth-client-node";
+import { Client } from "@libsql/client/.";
+import { LibSQLDatabase } from "drizzle-orm/libsql";
+import { Context, Next } from "hono";
+import { createClient } from "./auth/client";
+import { Logger } from "pino";
+
+export type TealContext = Context<EnvWithCtx, any, any>;
+
+export type EnvWithCtx = {
+  Variables: Ctx;
+};
+
+export type Ctx = {
+  auth: NodeOAuthClient;
+  db: LibSQLDatabase<typeof import("/Users/natalie/Code/teal/db/schema")> & {
+    $client: Client;
+  };
+  logger: Logger<never, boolean>;
+};
+
+export const setupContext = async (
+  c: TealContext,
+  db: LibSQLDatabase<typeof import("/Users/natalie/Code/teal/db/schema")> & {
+    $client: Client;
+  },
+  logger: Logger<never, boolean>,
+  next: Next,
+) => {
+  const auth = await createClient(db);
+
+  c.set("db", db);
+  c.set("auth", auth);
+  c.set("logger", logger);
+  await next();
+};

apps/aqua/src/db.ts

···
+import { drizzle } from "drizzle-orm/libsql";
+import * as schema from "../db/schema";
+import process from "node:process";
+
+export const db = drizzle({
+  connection: process.env.DATABASE_URL ?? "file:./db.sqlite",
+  // doesn't seem to work?
+  //casing: "snake_case",
+  schema: schema,
+});
+
+export type Database = typeof db;

apps/aqua/src/index.ts

···
+import { serve as serveNode } from "@hono/node-server";
+import { Hono } from "hono";
+import { db } from "@/db";
+import { getAuthRouter, loginGet } from "./auth/router";
+import pino from "pino";
+import { EnvWithCtx, setupContext } from "./ctx";
+import { env } from "./lib/env";
+
+const logger = pino({ name: "server start" });
+
+const app = new Hono<EnvWithCtx>();
+
+app.use((c, next) => setupContext(c, db, logger, next));
+
+app.get("/", (c) => c.text("Hono meets Node.js"));
+
+app.get("/info", async (c) => {
+  const result = await db.query.status.findFirst().execute();
+  console.log("result", result);
+  return c.json(result);
+});
+
+app.route("/oauth", getAuthRouter());
+
+// const run = async () => {
+//   serve(
+//     {
+//       fetch: app.fetch,
+//       port: env.PORT,
+//       hostname: env.HOST,
+//     },
+//     (info) => {
+//       console.log(
+//         `Listening on ${info.address == "::1" ? "http://localhost" : info.address}:${info.port} (${info.family})`,
+//       );
+//     },
+//   );
+// };
+
+// run();
+
+export default app;

apps/aqua/src/lexicon/index.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import {
+  createServer as createXrpcServer,
+  Server as XrpcServer,
+  Options as XrpcOptions,
+  AuthVerifier,
+  StreamAuthVerifier,
+} from '@atproto/xrpc-server'
+import { schemas } from './lexicons'
+
+export function createServer(options?: XrpcOptions): Server {
+  return new Server(options)
+}
+
+export class Server {
+  xrpc: XrpcServer
+  app: AppNS
+  xyz: XyzNS
+
+  constructor(options?: XrpcOptions) {
+    this.xrpc = createXrpcServer(schemas, options)
+    this.app = new AppNS(this)
+    this.xyz = new XyzNS(this)
+  }
+}
+
+export class AppNS {
+  _server: Server
+  bsky: AppBskyNS
+
+  constructor(server: Server) {
+    this._server = server
+    this.bsky = new AppBskyNS(server)
+  }
+}
+
+export class AppBskyNS {
+  _server: Server
+  actor: AppBskyActorNS
+
+  constructor(server: Server) {
+    this._server = server
+    this.actor = new AppBskyActorNS(server)
+  }
+}
+
+export class AppBskyActorNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+}
+
+export class XyzNS {
+  _server: Server
+  statusphere: XyzStatusphereNS
+
+  constructor(server: Server) {
+    this._server = server
+    this.statusphere = new XyzStatusphereNS(server)
+  }
+}
+
+export class XyzStatusphereNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+}
+
+type SharedRateLimitOpts<T> = {
+  name: string
+  calcKey?: (ctx: T) => string
+  calcPoints?: (ctx: T) => number
+}
+type RouteRateLimitOpts<T> = {
+  durationMs: number
+  points: number
+  calcKey?: (ctx: T) => string
+  calcPoints?: (ctx: T) => number
+}
+type HandlerOpts = { blobLimit?: number }
+type HandlerRateLimitOpts<T> = SharedRateLimitOpts<T> | RouteRateLimitOpts<T>
+type ConfigOf<Auth, Handler, ReqCtx> =
+  | Handler
+  | {
+      auth?: Auth
+      opts?: HandlerOpts
+      rateLimit?: HandlerRateLimitOpts<ReqCtx> | HandlerRateLimitOpts<ReqCtx>[]
+      handler: Handler
+    }
+type ExtractAuth<AV extends AuthVerifier | StreamAuthVerifier> = Extract<
+  Awaited<ReturnType<AV>>,
+  { credentials: unknown }
+>

apps/aqua/src/lexicon/lexicons.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { LexiconDoc, Lexicons } from '@atproto/lexicon'
+
+export const schemaDict = {
+  AppBskyActorProfile: {
+    lexicon: 1,
+    id: 'app.bsky.actor.profile',
+    defs: {
+      main: {
+        type: 'record',
+        description: 'A declaration of a Bluesky account profile.',
+        key: 'literal:self',
+        record: {
+          type: 'object',
+          properties: {
+            displayName: {
+              type: 'string',
+              maxGraphemes: 64,
+              maxLength: 640,
+            },
+            description: {
+              type: 'string',
+              description: 'Free-form profile description text.',
+              maxGraphemes: 256,
+              maxLength: 2560,
+            },
+            avatar: {
+              type: 'blob',
+              description:
+                "Small image to be displayed next to posts from account. AKA, 'profile picture'",
+              accept: ['image/png', 'image/jpeg'],
+              maxSize: 1000000,
+            },
+            banner: {
+              type: 'blob',
+              description:
+                'Larger horizontal image to display behind profile view.',
+              accept: ['image/png', 'image/jpeg'],
+              maxSize: 1000000,
+            },
+            labels: {
+              type: 'union',
+              description:
+                'Self-label values, specific to the Bluesky application, on the overall account.',
+              refs: ['lex:com.atproto.label.defs#selfLabels'],
+            },
+            joinedViaStarterPack: {
+              type: 'ref',
+              ref: 'lex:com.atproto.repo.strongRef',
+            },
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+            },
+          },
+        },
+      },
+    },
+  },
+  XyzStatusphereStatus: {
+    lexicon: 1,
+    id: 'xyz.statusphere.status',
+    defs: {
+      main: {
+        type: 'record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['status', 'createdAt'],
+          properties: {
+            status: {
+              type: 'string',
+              minLength: 1,
+              maxGraphemes: 1,
+              maxLength: 32,
+            },
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+            },
+          },
+        },
+      },
+    },
+  },
+}
+export const schemas: LexiconDoc[] = Object.values(schemaDict) as LexiconDoc[]
+export const lexicons: Lexicons = new Lexicons(schemas)
+export const ids = {
+  AppBskyActorProfile: 'app.bsky.actor.profile',
+  XyzStatusphereStatus: 'xyz.statusphere.status',
+}

apps/aqua/src/lexicon/types/app/bsky/actor/profile.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs'
+import * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef'
+
+export interface Record {
+  displayName?: string
+  /** Free-form profile description text. */
+  description?: string
+  /** Small image to be displayed next to posts from account. AKA, 'profile picture' */
+  avatar?: BlobRef
+  /** Larger horizontal image to display behind profile view. */
+  banner?: BlobRef
+  labels?:
+    | ComAtprotoLabelDefs.SelfLabels
+    | { $type: string; [k: string]: unknown }
+  joinedViaStarterPack?: ComAtprotoRepoStrongRef.Main
+  createdAt?: string
+  [k: string]: unknown
+}
+
+export function isRecord(v: unknown): v is Record {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    (v.$type === 'app.bsky.actor.profile#main' ||
+      v.$type === 'app.bsky.actor.profile')
+  )
+}
+
+export function validateRecord(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.actor.profile#main', v)
+}

apps/aqua/src/lexicon/types/xyz/statusphere/status.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../lexicons'
+import { isObj, hasProp } from '../../../util'
+import { CID } from 'multiformats/cid'
+
+export interface Record {
+  status: string
+  createdAt: string
+  [k: string]: unknown
+}
+
+export function isRecord(v: unknown): v is Record {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    (v.$type === 'xyz.statusphere.status#main' ||
+      v.$type === 'xyz.statusphere.status')
+  )
+}
+
+export function validateRecord(v: unknown): ValidationResult {
+  return lexicons.validate('xyz.statusphere.status#main', v)
+}

apps/aqua/src/lexicon/util.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+export function isObj(v: unknown): v is Record<string, unknown> {
+  return typeof v === 'object' && v !== null
+}
+
+export function hasProp<K extends PropertyKey>(
+  data: object,
+  prop: K,
+): data is Record<K, unknown> {
+  return prop in data
+}

apps/aqua/src/lib/env.ts

···
+import dotenv from "dotenv";
+import { cleanEnv, host, port, str, testOnly } from "envalid";
+import process from "node:process";
+
+dotenv.config();
+
+export const env = cleanEnv(process.env, {
+  NODE_ENV: str({
+    devDefault: testOnly("test"),
+    choices: ["development", "production", "test"],
+  }),
+  HOST: host({ devDefault: testOnly("0.0.0.0") }),
+  PORT: port({ devDefault: testOnly(3000) }),
+  PUBLIC_URL: str({}),
+  DB_PATH: str({ devDefault: "file:./db.sqlite" }),
+  COOKIE_SECRET: str({ devDefault: "secret_cookie! very secret!" }),
+});

apps/aqua/src/lib/view.ts

···
+// @ts-ignore
+import ssr from "uhtml/ssr";
+import type initSSR from "uhtml/types/init-ssr";
+import type { Hole } from "uhtml/types/keyed";
+
+export type { Hole };
+
+export const { html }: ReturnType<typeof initSSR> = ssr();
+
+export function page(hole: Hole) {
+  return `<!DOCTYPE html>\n${hole.toDOM().toString()}`;
+}

apps/aqua/tsconfig.json

···
+{
+  "extends": "@teal/tsconfig/base.json",
+  "compilerOptions": {
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  }
+}

apps/viridian/go.mod

···
+module viridian
+
+go 1.21.5
+
+require github.com/pebbe/zmq4 v1.2.11

apps/viridian/go.sum

···
+github.com/pebbe/zmq4 v1.2.11 h1:Ua5mgIaZeabUGnH7tqswkUcjkL7JYGai5e8v4hpEU9Q=
+github.com/pebbe/zmq4 v1.2.11/go.mod h1:nqnPueOapVhE2wItZ0uOErngczsJdLOGkebMxaO8r48=

apps/viridian/main.go

···
+package main
+
+import (
+	"fmt"
+	"sync"
+
+	server "viridian/server"
+	worker "viridian/worker"
+)
+
+func main() {
+	var wg sync.WaitGroup
+
+	// Run the server in a goroutine
+	go server.RunServer()
+
+	// Simulate workers, each running in a separate goroutine
+	workerCount := worker.GetCoreCount()
+	fmt.Printf("Starting %d workers\n", workerCount)
+	for i := 1; i <= workerCount; i++ {
+		fmt.Printf("Starting worker %d\n", i)
+		workerID := fmt.Sprintf("worker-%d", i)
+		wg.Add(1)
+		go worker.RunWorker(workerID, &wg)
+	}
+
+	// Wait for all workers to complete (this won't happen in this example since workers run indefinitely)
+	wg.Wait()
+}

apps/viridian/package.json

···
+{
+  "name": "@teal/viridian",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "install": "go mod download",
+    "build": "go build main.go",
+    "dev": "go run main.go",
+    "start": "go run main.go"
+  }
+}

apps/viridian/server/server.go

···
+package server
+
+import (
+	"fmt"
+	"time"
+
+	"viridian/types"
+
+	zmq "github.com/pebbe/zmq4"
+)
+
+// RunServer launches the server that distributes jobs to workers
+func RunServer() {
+	server := &types.Server{
+		Jobs:       []types.Job{{"job1", "pending"}, {"job2", "pending"}, {"job3", "pending"}},
+		WorkerJobs: make(map[string]string),
+		JobStatus:  make(map[string]string),
+	}
+
+	// Initialize job status
+	for _, job := range server.Jobs {
+		server.JobStatus[job.ID] = "pending"
+	}
+
+	// Create a ZeroMQ ROUTER socket for distributing jobs
+	socket, _ := zmq.NewSocket(zmq.ROUTER)
+	defer socket.Close()
+	socket.Bind("tcp://*:5555")
+
+	for len(server.Jobs) > 0 {
+		// Wait for a worker to send a ready message
+		workerAddr, _ := socket.RecvMessage(0)
+
+		fmt.Printf("Received ready message from worker %s\n", workerAddr)
+
+		fmt.Print(workerAddr[2])
+
+		// Lock jobs to pick the next one safely
+		server.Mu.Lock()
+		if len(server.Jobs) == 0 {
+			server.Mu.Unlock()
+			continue
+		}
+		job := server.Jobs[0]
+		server.Jobs = server.Jobs[1:]
+		server.Mu.Unlock()
+
+		// Track the job for this worker
+		server.TrackJob(workerAddr[0], job.ID)
+
+		// Send job to the worker
+		fmt.Printf("Sending job %s to worker %s\n", job.ID, workerAddr[0])
+		socket.SendMessage(workerAddr[0], "", job.ID)
+
+		time.Sleep(1 * time.Second) // Simulate a delay
+
+		// In a real-world scenario, this would be based on a worker response
+		server.MarkJobCompleted(workerAddr[0])
+	}
+
+	fmt.Println("All jobs processed")
+}

apps/viridian/types/types.go

···
+package types
+
+import (
+	"strconv"
+	"sync"
+)
+
+// Job represents a job with an ID and status
+type Job struct {
+	ID     string
+	Status string
+}
+
+// Server represents the state of the server, including jobs, worker-job associations, and job status
+type Server struct {
+	Jobs       []Job             // Job queue
+	WorkerJobs map[string]string // Mapping worker ID -> job ID
+	JobStatus  map[string]string // Mapping job ID -> status
+	Mu         sync.Mutex        // Mutex to handle concurrency
+}
+
+func (s *Server) AddJob() Job {
+	s.Mu.Lock()
+	defer s.Mu.Unlock()
+	job := Job{"job" + strconv.Itoa(len(s.Jobs)), "pending"}
+	s.Jobs = append(s.Jobs, job)
+
+	return job
+}
+
+// TrackJob assigns a job to a worker and marks it as in-progress
+func (s *Server) TrackJob(workerID, jobID string) {
+	s.Mu.Lock()
+	defer s.Mu.Unlock()
+	s.WorkerJobs[workerID] = jobID
+	s.JobStatus[jobID] = "in-progress"
+}
+
+// MarkJobCompleted marks a job as completed and removes the worker-job association
+func (s *Server) MarkJobCompleted(workerID string) {
+	s.Mu.Lock()
+	defer s.Mu.Unlock()
+	jobID := s.WorkerJobs[workerID]
+	s.JobStatus[jobID] = "completed"
+	delete(s.WorkerJobs, workerID) // Remove worker-job association
+}

apps/viridian/worker/ffmpeg.go

···
+package worker

apps/viridian/worker/worker.go

···
+package worker
+
+import (
+	"fmt"
+	"runtime"
+	"sync"
+	"time"
+
+	zmq "github.com/pebbe/zmq4"
+)
+
+// RunWorker simulates a worker that connects to the server and processes jobs
+func RunWorker(id string, wg *sync.WaitGroup) {
+	defer wg.Done()
+
+	// Create a ZeroMQ REQ socket for receiving jobs
+	socket, _ := zmq.NewSocket(zmq.REQ)
+	defer socket.Close()
+	socket.Connect("tcp://localhost:5555")
+
+	for {
+		// Send a ready signal to the server
+		socket.SendMessage(fmt.Sprintf("READY %s", id), 0)
+
+		// Receive the job
+		msg, err := socket.RecvMessage(0)
+		if err != nil {
+			fmt.Println("Error receiving job:", err)
+			continue
+		}
+		job := msg[0]
+
+		// Process the job
+		fmt.Printf("Worker %s received job: %s\n", id, job)
+		socket.SendMessage(fmt.Sprintf("RECEIVED %s", job), 0)
+
+		// Simulate processing the job
+		fmt.Printf("Worker %s processing job: %s\n", id, job)
+		socket.SendMessage(fmt.Sprintf("PROCESSING %s", job), 0)
+		time.Sleep(2 * time.Second) // Simulate job processing delay
+	}
+}
+
+// GetCoreCount returns the number of CPU cores on the current machine
+func GetCoreCount() int {
+	return runtime.NumCPU()
+}

compose.dev.yml

···
+services:
+  traefik:
+    image: traefik:v2.10
+    container_name: traefik
+    command:
+      - "--api.insecure=true"
+      - "--providers.file.directory=/etc/traefik/dynamic"
+      - "--providers.file.watch=true"
+      - "--entrypoints.web.address=:80"
+    ports:
+      - "80:80" # HTTP
+      - "8080:8080" # Dashboard
+    volumes:
+      - ./traefik/dynamic:/etc/traefik/dynamic:ro
+    networks:
+      - app_network
+    extra_hosts:
+      - "host.docker.internal:host-gateway" # This allows reaching host machine
+
+  postgres:
+    image: postgres:latest
+    container_name: postgres_db
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: yourpassword
+      POSTGRES_DB: yourdatabase
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    networks:
+      - app_network
+
+  redis:
+    image: redis:latest
+    container_name: redis_cache
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis_data:/data
+    command: redis-server --appendonly yes
+    networks:
+      - app_network
+
+networks:
+  app_network:
+    driver: bridge
+
+volumes:
+  postgres_data:
+  redis_data:

lexicons/app.bsky.actor.profile.json

···
+{
+  "lexicon": 1,
+  "id": "app.bsky.actor.profile",
+  "defs": {
+    "main": {
+      "type": "record",
+      "description": "A declaration of a Bluesky account profile.",
+      "key": "literal:self",
+      "record": {
+        "type": "object",
+        "properties": {
+          "displayName": {
+            "type": "string",
+            "maxGraphemes": 64,
+            "maxLength": 640
+          },
+          "description": {
+            "type": "string",
+            "description": "Free-form profile description text.",
+            "maxGraphemes": 256,
+            "maxLength": 2560
+          },
+          "avatar": {
+            "type": "blob",
+            "description": "Small image to be displayed next to posts from account. AKA, 'profile picture'",
+            "accept": ["image/png", "image/jpeg"],
+            "maxSize": 1000000
+          },
+          "banner": {
+            "type": "blob",
+            "description": "Larger horizontal image to display behind profile view.",
+            "accept": ["image/png", "image/jpeg"],
+            "maxSize": 1000000
+          },
+          "labels": {
+            "type": "union",
+            "description": "Self-label values, specific to the Bluesky application, on the overall account.",
+            "refs": ["com.atproto.label.defs#selfLabels"]
+          },
+          "joinedViaStarterPack": {
+            "type": "ref",
+            "ref": "com.atproto.repo.strongRef"
+          },
+          "createdAt": { "type": "string", "format": "datetime" }
+        }
+      }
+    }
+  }
+}

lexicons/xyz.statusphere.status.json

···
+{
+  "lexicon": 1,
+  "id": "xyz.statusphere.status",
+  "defs": {
+    "main": {
+      "type": "record",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "required": ["status", "createdAt"],
+        "properties": {
+          "status": {
+            "type": "string",
+            "minLength": 1,
+            "maxGraphemes": 1,
+            "maxLength": 32
+          },
+          "createdAt": { "type": "string", "format": "datetime" }
+        }
+      }
+    }
+  }
+}

package.json

···
 {
   "name": "teal",
-  "version": "1.0.50",
+  "private": true,
+  "version": "0.0.0",
+  "packageManager": "bun@1.0.0+",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "dev": "bun run --watch src/index.ts"
+    "install": "turbo run install",
+    "build": "turbo run build",
+    "dev": "turbo run dev",
+    "lint": "turbo run lint"
   },
-  "dependencies": {
-    "elysia": "latest"
+  "devDependencies": {
+    "turbo": "latest"
   },
-  "devDependencies": {
-    "bun-types": "latest"
+  "engines": {
+    "node": ">=20.0.0"
   },
-  "module": "src/index.js"
-}
+  "workspaces": [
+    "apps/*",
+    "packages/*"
+  ]
+}

packages/tsconfig/package.json

···
+{
+  "name": "@teal/tsconfig"
+}

src/index.ts

···
-import { Elysia } from "elysia";
-
-const app = new Elysia().get("/", () => "Hello Elysia").listen(3000);
-
-console.log(
-  `🦊 Elysia is running at ${app.server?.hostname}:${app.server?.port}`
-);

traefik/dev_routes.yml

···
+http:
+  routers:
+    frontend:
+      rule: "PathPrefix(`/`)"
+      service: frontend
+      priority: 1
+
+    backend:
+      rule: "PathPrefix(`/api`)"
+      service: backend
+      priority: 2
+
+  services:
+    frontend:
+      loadBalancer:
+        servers:
+          - url: "http://host.docker.internal:3000"
+
+    backend:
+      loadBalancer:
+        servers:
+          - url: "http://host.docker.internal:3031"

traefik/dynamic_conf.yml

···
+http:
+  middlewares:
+    security-headers:
+      headers:
+        frameDeny: true
+        sslRedirect: true
+        browserXssFilter: true
+        contentTypeNosniff: true
+        forceSTSHeader: true
+        stsIncludeSubdomains: true
+        stsPreload: true
+        stsSeconds: 31536000
+
+    cors-headers:
+      headers:
+        accessControlAllowMethods:
+          - GET
+          - POST
+          - PUT
+          - DELETE
+          - OPTIONS
+        accessControlAllowHeaders:
+          - "*"
+        accessControlAllowOrigin: "*"

traefik/traefik.yml

···
+api:
+  insecure: true
+  dashboard: true
+
+entryPoints:
+  web:
+    address: ":80"
+    http:
+      redirections:
+        entryPoint:
+          to: websecure
+          scheme: https
+
+  websecure:
+    address: ":443"
+
+providers:
+  docker:
+    endpoint: "unix:///var/run/docker.sock"
+    exposedByDefault: false
+    network: app_network
+
+  file:
+    filename: /etc/traefik/dynamic_conf.yml
+
+certificatesResolvers:
+  letsencrypt:
+    acme:
+      email: [e-mail]
+      storage: /letsencrypt/acme.json
+      httpChallenge:
+        entryPoint: web
+http:
+  middlewares:
+    security-headers:
+      headers:
+        frameDeny: true
+        sslRedirect: true
+        browserXssFilter: true
+        contentTypeNosniff: true
+        forceSTSHeader: true
+        stsIncludeSubdomains: true
+        stsPreload: true
+        stsSeconds: 31536000
+
+    cors-headers:
+      headers:
+        accessControlAllowMethods:
+          - GET
+          - POST
+          - PUT
+          - DELETE
+          - OPTIONS
+        accessControlAllowHeaders:
+          - "*"
+        accessControlAllowOrigin: "*"

tsconfig.json packages/tsconfig/base.json

···
     // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
 
     /* Language and Environment */
-    "target": "ES2021",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "target": "ES2021" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
     // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
     // "jsx": "preserve",                                /* Specify what JSX code is generated. */
     // "experimentalDecorators": true,                   /* Enable experimental support for TC39 stage 2 draft decorators. */
···
     // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
 
     /* Modules */
-    "module": "ES2022",                                /* Specify what module code is generated. */
+    "module": "ES2022" /* Specify what module code is generated. */,
     // "rootDir": "./",                                  /* Specify the root folder within your source files. */
-    "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
+    "moduleResolution": "node" /* Specify how TypeScript looks up a file from a given module specifier. */,
     // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
-    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    //"paths": {} /* Specify a set of entries that re-map imports to additional lookup locations. */,
     // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
     // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
-    "types": ["bun-types"],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "types": [] /* Specify type package names to be included without being referenced in a source file. */,
     // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
     // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
     // "resolveJsonModule": true,                        /* Enable importing .json files. */
···
     /* Interop Constraints */
     // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
     // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
-    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,
     // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
-    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+    "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
 
     /* Type Checking */
-    "strict": true,                                      /* Enable all strict type-checking options. */
+    "strict": true /* Enable all strict type-checking options. */,
     // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
     // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
···
 
     /* Completeness */
     // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
-    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+    "skipLibCheck": true /* Skip type checking all .d.ts files. */
   }
 }

turbo.json

···
+{
+  "$schema": "https://turbo.build/schema.json",
+  "tasks": {
+    "install": {
+      "dependsOn": ["^install"]
+    },
+    "build": {
+      "dependsOn": ["^build"],
+      "outputs": [".next/**", "!.next/cache/**"]
+    },
+    "check-types": {
+      "dependsOn": ["^check-types"]
+    },
+    "dev": {
+      "persistent": true,
+      "cache": false
+    }
+  }
+}