benjivers/notes Public Public: anyone can read this; nobody can change it.

/**

 * The process the forge runs. `serve` opens the database and listens:

 * every request gets the floor (`http.ts`), an identity (`who.ts`), the

 * door (`security.ts`) and one route (`routes.ts`) — so a request from

 * another site, from someone going too fast, or from someone the contract

 * turns away is refused before a byte of it is read. Run directly, it

 * serves what the forge said; a test calls `serve` with its own.

 */

import { openDb } from "./db.ts";

import { dataDir, forgeApi, identityKey, repoToken, title, where } from "./env.ts";

import { sessionWho } from "./accounts.ts";

import { html, readCookie, text } from "./http.ts";

import { SESSION_COOKIE } from "./routes.ts";

import { match } from "./routes.ts";

import { door } from "./security.ts";

import { httpForge, startSync, type Forge } from "./sync.ts";

import { who } from "./who.ts";

import { traceServe } from "./otel.ts";

export interface ServeOptions {

  readonly port: number;

  readonly hostname?: string | undefined;

  readonly dataDir: string;

  readonly identityKey: string;

  /** Where shared folders commit; without one there are none. */

  readonly forge?: Forge | undefined;

}

export function serve(options: ServeOptions) {

  const db = openDb(options.dataDir);

  const stopSync = startSync(db, options.forge);

  const server = Bun.serve(traceServe({

    port: options.port,

    hostname: options.hostname ?? "127.0.0.1",

    // A connection that says nothing for a minute is dropped. The event

    // stream heartbeats every 25 seconds to stay well inside that.

    idleTimeout: 60,

    async fetch(request, server) {

      const url = new URL(request.url);

      // The forge's signed word first; else the app's own session, if any.

      const signed = who(request, options.identityKey);

      const me =

        signed.role === "anon" ? sessionWho(db, readCookie(request, SESSION_COOKIE)) : signed;

      const refused = door(

        db,

        request,

        url,

        me,

        server.requestIP(request)?.address ?? "?",

      );

      if (refused !== undefined) return head(request, refused);

      const found = match(

        request.method === "HEAD" ? "GET" : request.method,

        url.pathname,

      );

      if (found === undefined) return text("not found", 404);

      const response = await found.route.handle({

        request,

        url,

        db,

        who: me,

        params: found.params,

        forge: options.forge,

      });

      return head(request, response);

    },

    // A bug answers with the floor and nothing else: never the runtime's

    // own error page, which carries source and paths, and never without

    // the headers. The detail goes to the log, where it belongs.

    error(error) {

      console.error(error);

      return html("<h1>Something went wrong</h1>", 500);

    },

  }));

  const stop = server.stop.bind(server);

  server.stop = (force?: boolean) => {

    stopSync();

    return stop(force);

  };

  return server;

}

// HEAD is GET without the body: a health check sees the app up.

const head = (request: Request, response: Response): Response =>

  request.method === "HEAD"

    ? new Response(null, { status: response.status, headers: response.headers })

    : response;

if (import.meta.main) {

  const server = serve({

    port: Number(process.env.PORT ?? 8080),

    hostname: process.env.HOST,

    dataDir,

    identityKey,

    forge: repoToken === undefined || forgeApi === undefined ? undefined : httpForge(forgeApi, repoToken),

  });

  console.log(

    `${title} listening on http://${server.hostname}:${server.port} (${where})`,

  );

}