A local-first multi-agent app development platform, built on PenguinHarness
import { Interface, Module, Provide, Use } from "@adelie/core/kernel";
import type { Opaque, Slot, ClassCtx } from "@adelie/core/kernel";
import { Hono } from "hono";
import type { AppEnv } from "../auth/middleware.js";
import { Config, Log } from "../hmr/capabilities.js";
import type { MiddlewareHandler } from "hono";
import { bodyLimit } from "hono/body-limit";
import { authMiddleware, jsonOnlyWrites } from "../auth/middleware.js";
import { AMSP_PREFIX, amspAllowOrigin } from "../amsp/cors.js";
import { HttpError, handleError, normalizeError } from "./errors.js";
import { attributedProjectId } from "./attribution.js";
import { bodyLimitBytes } from "../services/attachment-limits.js";
import { declined } from "../hmr/hono-seam.js";
import type { Auth } from "../mechanisms/identity.js";
import type { Access } from "../mechanisms/projects.js";
import type { Errors } from "../mechanisms/observability.js";
import type { Settings } from "../mechanisms/settings.js";
/** The assembled business surface: one request in, one response (or a decline) out. */
@Interface()
export abstract class Http {
abstract fetch(request: Opaque<"Request", Request>): Promise<Opaque<"Response", Response>>;
}
export interface HttpSlots {
/**
* A route group. `auth: "user"` mounts it behind the cookie gate, `"none"` in front of
* it; `order` is the mount position (a stable number, since Hono matches in order). The
* code half is the group's Hono app.
*/
routes: Slot<
{ prefix: string; auth: "user" | "none"; order: number },
Opaque<"Hono", Hono<AppEnv>>
>;
}
/**
* The platform's whole HTTP surface, assembled from `HttpModule.routes` contributions: every
* module that serves requests contributes its groups here as data (prefix, auth, order)
* and binds the Hono app by id. Adding an endpoint is adding a line to a manifest.
*/
@Module()
export class HttpModule {
@Use() private readonly config!: Config;
@Use() private readonly log!: Log;
@Use() private readonly auth!: Auth;
@Use() private readonly errors!: Errors;
@Use() private readonly settings!: Settings;
@Use() private readonly access!: Access;
@Provide() http!: Http;
setup({ contributions }: ClassCtx) {
const errors = this.errors;
const access = this.access;
const app = new Hono<AppEnv>();
app.onError((err, c) => {
const projectId = attributedProjectId(c, { access });
// Normalize first: response and recording must agree on what this error is (see errors.ts).
const normalized = normalizeError(err);
errors.record({
source: "http",
err: normalized,
...(projectId !== undefined ? { ctx: { projectId } } : {}),
});
return handleError(normalized, c);
});
app.notFound(() => declined());
app.use("*", async (c, next) => {
const start = performance.now();
await next();
this.log.line(
`${c.req.method} ${c.req.path} ${c.res.status} ${Math.round(performance.now() - start)}ms`,
);
});
// The same header the host layer puts ahead of its copies of these two checks (src/app.ts):
// their refusals answer before the Agent API's group runs, and a browser caller must read the
// code, not a CORS failure.
app.use(`${AMSP_PREFIX}/*`, amspAllowOrigin);
let capped: { size: number; mw: MiddlewareHandler } | null = null;
app.use("/api/*", (c, next) => {
const size = bodyLimitBytes(this.settings.getAttachmentLimitsMb());
if (capped === null || capped.size !== size) {
capped = {
size,
mw: bodyLimit({
maxSize: size,
onError: () => {
throw new HttpError(
413,
"payload_too_large",
`Request body exceeds the ${Math.floor(size / (1024 * 1024))}MB limit.`,
);
},
}),
};
}
return capped.mw(c, next);
});
app.use("/api/*", jsonOnlyWrites);
const routes = [...(contributions.routes ?? [])]
.map((c) => ({
id: c.id,
prefix: c.data.prefix as string,
auth: c.data.auth as "user" | "none",
order: c.data.order as number,
app: c.code as Hono<AppEnv>,
}))
.sort((a, b) => a.order - b.order || a.id.localeCompare(b.id));
// Protected routes: cookie -> auth_session -> user. Built once, mounted per group, and
// run once per request: prefixes nest (/api/projects, /api/projects/:projectId/members),
// so a request can pass several mounts, and the first is the one that authenticates.
const authenticate = authMiddleware(this.auth, this.config.trustProxy);
const gate: MiddlewareHandler<AppEnv> = (c, next) =>
(c.var.user as AppEnv["Variables"]["user"] | undefined) === undefined
? authenticate(c, next)
: next();
for (const r of routes) {
// The gate sits on each group that asked for it, not once on `/api/*` ahead of the
// first such group: a contributor picks its own prefix and order, and `auth` has to
// mean the same thing wherever the group lands — a public group ordered after a
// protected one stays public, and a protected group outside /api (the machine proxy
// at /server/) is still protected. The gate is also what puts the user on the context.
if (r.auth === "user") app.use(`${r.prefix.replace(/\/$/, "")}/*`, gate);
app.route(r.prefix, r.app);
}
this.http = { fetch: (request: Request) => Promise.resolve(app.fetch(request)) };
}
}