@larose/pi-web 0.3.0

package/src/server/server.ts

@@ -0,0 +1,248 @@
+import { readFile } from "node:fs/promises";
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { handleApi, type ApiContext, writeApiError } from "./api.js";
+import { DirectoryBrowser } from "./directory-browser.js";
+import { AppError } from "./errors.js";
+import { GitWorkspaceService } from "./git-workspaces.js";
+import { createRuntimeRegistry, type RuntimeRegistry } from "./runtime-registry.js";
+import { SessionRepository } from "./session-repository.js";
+
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+
+interface StaticAsset {
+  path: string;
+  contentType: string;
+}
+
+const homeDocument: StaticAsset = {
+  path: join(packageRoot, "public/home.html"),
+  contentType: "text/html; charset=utf-8",
+};
+const sessionDocument: StaticAsset = {
+  path: join(packageRoot, "public/session.html"),
+  contentType: "text/html; charset=utf-8",
+};
+const staticFiles = new Map<string, StaticAsset>([
+  ["/", homeDocument],
+  ["/styles.css", { path: join(packageRoot, "public/styles.css"), contentType: "text/css; charset=utf-8" }],
+  ["/home.js", { path: join(packageRoot, "dist/client/home.js"), contentType: "text/javascript; charset=utf-8" }],
+  ["/session.js", { path: join(packageRoot, "dist/client/session.js"), contentType: "text/javascript; charset=utf-8" }],
+]);
+
+export interface WebServerOptions {
+  hostname?: string;
+  port?: number;
+  startupCwd?: string;
+  context?: Omit<ApiContext, "directories" | "gitWorkspaces"> &
+    Partial<Pick<ApiContext, "directories" | "gitWorkspaces">>;
+}
+
+export interface RunningWebServer {
+  hostname: string;
+  port: number;
+  server: Server;
+  repository: SessionRepository;
+  runtimes: RuntimeRegistry;
+  directories: ApiContext["directories"];
+  gitWorkspaces: ApiContext["gitWorkspaces"];
+  close(): Promise<void>;
+}
+
+function errorDetails(error: unknown): string {
+  if (!(error instanceof Error)) {
+    return String(error);
+  }
+
+  const details = error.stack ?? error.message;
+  return error.cause === undefined ? details : `${details}\nCaused by: ${errorDetails(error.cause)}`;
+}
+
+function shouldReportError(error: unknown): boolean {
+  return !(error instanceof AppError) || error.status >= 500 || error.cause !== undefined;
+}
+
+function applySecurityHeaders(response: ServerResponse): void {
+  response.setHeader(
+    "content-security-policy",
+    "default-src 'self'; base-uri 'none'; connect-src 'self'; form-action 'self'; frame-ancestors 'none'; object-src 'none'; script-src 'self'; style-src 'self'",
+  );
+  response.setHeader("referrer-policy", "no-referrer");
+  response.setHeader("x-content-type-options", "nosniff");
+  response.setHeader("x-frame-options", "DENY");
+}
+
+function boundPort(server: Server): number {
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    throw new Error("Server is not bound to a TCP address");
+  }
+  return address.port;
+}
+
+function validateLocalRequest(request: IncomingMessage, server: Server): void {
+  const host = request.headers.host;
+  if (!host) {
+    throw new AppError("invalid_host", "A Host header is required", 403);
+  }
+
+  let hostUrl: URL;
+  try {
+    hostUrl = new URL(`http://${host}`);
+  } catch {
+    throw new AppError("invalid_host", "The Host header is invalid", 403);
+  }
+
+  const expectedPort = String(boundPort(server));
+  if (!new Set(["127.0.0.1", "localhost"]).has(hostUrl.hostname) || hostUrl.port !== expectedPort) {
+    throw new AppError("invalid_host", "The Host header is not allowed", 403);
+  }
+
+  const origin = request.headers.origin;
+  if (!origin) {
+    return;
+  }
+
+  try {
+    const originUrl = new URL(origin);
+    if (
+      originUrl.protocol !== "http:" ||
+      !new Set(["127.0.0.1", "localhost"]).has(originUrl.hostname) ||
+      originUrl.port !== expectedPort
+    ) {
+      throw new Error("Origin does not match the local server");
+    }
+  } catch {
+    throw new AppError("invalid_origin", "The Origin header is not allowed", 403);
+  }
+}
+
+async function serveAsset(asset: StaticAsset, response: ServerResponse): Promise<void> {
+  const contents = await readFile(asset.path);
+
+  response.writeHead(200, {
+    "cache-control": "no-store",
+    "content-length": contents.byteLength,
+    "content-type": asset.contentType,
+  });
+  response.end(contents);
+}
+
+async function serveStatic(pathname: string, response: ServerResponse): Promise<boolean> {
+  const asset = staticFiles.get(pathname);
+  if (!asset) {
+    return false;
+  }
+
+  await serveAsset(asset, response);
+  return true;
+}
+
+function newSessionSource(pathname: string): string | undefined {
+  const match = /^\/sessions\/([^/]+)\/new\/?$/.exec(pathname);
+  if (!match?.[1]) {
+    return undefined;
+  }
+
+  try {
+    return decodeURIComponent(match[1]);
+  } catch {
+    throw new AppError("invalid_path", "The source session id is not valid", 400);
+  }
+}
+
+export async function startServer(options: WebServerOptions = {}): Promise<RunningWebServer> {
+  const hostname = options.hostname ?? "127.0.0.1";
+  const port = options.port ?? 31_415;
+
+  if (hostname !== "127.0.0.1") {
+    throw new Error("Pi Web only supports the loopback host 127.0.0.1");
+  }
+
+  const repository =
+    options.context?.repository ?? (await SessionRepository.create(options.startupCwd ?? process.cwd()));
+  const runtimes = options.context?.runtimes ?? (await createRuntimeRegistry(repository));
+  const directories = options.context?.directories ?? new DirectoryBrowser();
+  const gitWorkspaces = options.context?.gitWorkspaces ?? new GitWorkspaceService();
+  const context: ApiContext = { repository, runtimes, directories, gitWorkspaces };
+  let closing: Promise<void> | undefined;
+
+  const server = createServer(async (request, response) => {
+    applySecurityHeaders(response);
+
+    try {
+      validateLocalRequest(request, server);
+      const url = new URL(request.url ?? "/", "http://127.0.0.1");
+
+      if (await handleApi(request, response, url.pathname, context)) {
+        return;
+      }
+
+      if (request.method === "GET") {
+        const sourceId = newSessionSource(url.pathname);
+        if (sourceId) {
+          await repository.get(sourceId);
+          await serveAsset(homeDocument, response);
+          return;
+        }
+
+        if (/^\/sessions\/[^/]+\/?$/.test(url.pathname)) {
+          await serveAsset(sessionDocument, response);
+          return;
+        }
+        if (await serveStatic(url.pathname, response)) {
+          return;
+        }
+      }
+
+      throw new AppError("not_found", "Not found", 404);
+    } catch (error) {
+      if (shouldReportError(error)) {
+        process.stderr.write(
+          `[pi-web] ${request.method ?? "UNKNOWN"} ${request.url ?? "/"} failed\n${errorDetails(error)}\n`,
+        );
+      }
+      writeApiError(response, error);
+    }
+  });
+
+  try {
+    await new Promise<void>((resolveListening, reject) => {
+      server.once("error", reject);
+      server.listen(port, hostname, () => {
+        server.off("error", reject);
+        resolveListening();
+      });
+    });
+  } catch (error) {
+    if (!options.context) {
+      await runtimes.close();
+    }
+    throw error;
+  }
+
+  return {
+    hostname,
+    port: boundPort(server),
+    server,
+    repository,
+    runtimes,
+    directories,
+    gitWorkspaces,
+    close: () => {
+      if (closing) {
+        return closing;
+      }
+
+      closing = (async () => {
+        await runtimes.close();
+        await new Promise<void>((resolveClose, reject) => {
+          server.close((error) => (error ? reject(error) : resolveClose()));
+        });
+      })();
+      return closing;
+    },
+  };
+}