@schlenkr/ragents 0.1.0

package/LICENSE

@@ -0,0 +1,166 @@
+Required Notice: Copyright 2026 Ronald Schlenker
+
+# PolyForm Shield License 1.0.0
+
+<https://polyformproject.org/licenses/shield/1.0.0>
+
+## Acceptance
+
+In order to get any license under these terms, you must agree
+to them as both strict obligations and conditions to all
+your licenses.
+
+## Copyright License
+
+The licensor grants you a copyright license for the
+software to do everything you might do with the software
+that would otherwise infringe the licensor's copyright
+in it for any permitted purpose.  However, you may
+only distribute the software according to [Distribution
+License](#distribution-license) and make changes or new works
+based on the software according to [Changes and New Works
+License](#changes-and-new-works-license).
+
+## Distribution License
+
+The licensor grants you an additional copyright license
+to distribute copies of the software.  Your license
+to distribute covers distributing the software with
+changes and new works permitted by [Changes and New Works
+License](#changes-and-new-works-license).
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of
+the software from you also gets a copy of these terms or the
+URL for them above, as well as copies of any plain-text lines
+beginning with `Required Notice:` that the licensor provided
+with the software.  For example:
+
+> Required Notice: Copyright Yoyodyne, Inc. (http://example.com)
+
+## Changes and New Works License
+
+The licensor grants you an additional copyright license to
+make changes and new works based on the software for any
+permitted purpose.
+
+## Patent License
+
+The licensor grants you a patent license for the software that
+covers patent claims the licensor can license, or becomes able
+to license, that you would infringe by using the software.
+
+## Noncompete
+
+Any purpose is a permitted purpose, except for providing any
+product that competes with the software or any product the
+licensor or any of its affiliates provides using the software.
+
+## Competition
+
+Goods and services compete even when they provide functionality
+through different kinds of interfaces or for different technical
+platforms.  Applications can compete with services, libraries
+with plugins, frameworks with development tools, and so on,
+even if they're written in different programming languages
+or for different computer architectures.  Goods and services
+compete even when provided free of charge.  If you market a
+product as a practical substitute for the software or another
+product, it definitely competes.
+
+## New Products
+
+If you are using the software to provide a product that does
+not compete, but the licensor or any of its affiliates brings
+your product into competition by providing a new version of
+the software or another product using the software, you may
+continue using versions of the software available under these
+terms beforehand to provide your competing product, but not
+any later versions.
+
+## Discontinued Products
+
+You may begin using the software to compete with a product
+or service that the licensor or any of its affiliates has
+stopped providing, unless the licensor includes a plain-text
+line beginning with `Licensor Line of Business:` with the
+software that mentions that line of business.  For example:
+
+> Licensor Line of Business: YoyodyneCMS Content Management
+System (http://example.com/cms)
+
+## Sales of Business
+
+If the licensor or any of its affiliates sells a line of
+business developing the software or using the software
+to provide a product, the buyer can also enforce
+[Noncompete](#noncompete) for that product.
+
+## Fair Use
+
+You may have "fair use" rights for the software under the
+law. These terms do not limit them.
+
+## No Other Rights
+
+These terms do not allow you to sublicense or transfer any of
+your licenses to anyone else, or prevent the licensor from
+granting licenses to anyone else.  These terms do not imply
+any other licenses.
+
+## Patent Defense
+
+If you make any written claim that the software infringes or
+contributes to infringement of any patent, your patent license
+for the software granted under these terms ends immediately. If
+your company makes such a claim, your patent license ends
+immediately for work on behalf of your company.
+
+## Violations
+
+The first time you are notified in writing that you have
+violated any of these terms, or done anything with the software
+not covered by your licenses, your licenses can nonetheless
+continue if you come into full compliance with these terms,
+and take practical steps to correct past violations, within
+32 days of receiving notice.  Otherwise, all your licenses
+end immediately.
+
+## No Liability
+
+***As far as the law allows, the software comes as is, without
+any warranty or condition, and the licensor will not be liable
+to you for any damages arising out of these terms or the use
+or nature of the software, under any kind of legal claim.***
+
+## Definitions
+
+The **licensor** is the individual or entity offering these
+terms, and the **software** is the software the licensor makes
+available under these terms.
+
+A **product** can be a good or service, or a combination
+of them.
+
+**You** refers to the individual or entity agreeing to these
+terms.
+
+**Your company** is any legal entity, sole proprietorship,
+or other kind of organization that you work for, plus all
+its affiliates.
+
+**Affiliates** means the other organizations than an
+organization has control over, is under the control of, or is
+under common control with.
+
+**Control** means ownership of substantially all the assets of
+an entity, or the power to direct its management and policies
+by vote, contract, or otherwise.  Control can be direct or
+indirect.
+
+**Your licenses** are all the licenses granted to you for the
+software under these terms.
+
+**Use** means anything you do with the software requiring one
+of your licenses.

package/README.md

@@ -0,0 +1,88 @@
+# @schlenkr/ragents
+
+RAgents is a web workshop for AI agents: you chat with a coordinator that starts further agents and
+equips actors with TypeScript functions and their own views. Everything that happens goes into an
+append-only journal, and the state of a run is always rebuilt by replaying that journal.
+
+This package is the RAgents host - server, engine, plugins and the scripts behind the subcommands -
+so the host runs without a source checkout. Installing it gives you one command, `ragents`.
+
+## Install
+
+```sh
+npm install -g @schlenkr/ragents
+```
+
+## Commands
+
+- `connect <server-url>` - fetch the client profile of a RAgents server and start the local server
+  with it; the models come over the server's relay.
+
+  ```sh
+  RAGENTS_TOKEN=<token> ragents connect https://ragents.example.com
+  ```
+
+- `start <profile>` - start a profile shipped with the package (`core`, `developer`) or a stand that
+  `connect` already fetched, without asking the server.
+
+  ```sh
+  ragents start developer
+  ```
+
+- `provision [<profile>|--workspace]` - fetch the tools the plugins of that profile need, such as
+  the language servers; a second call downloads nothing.
+
+  ```sh
+  ragents provision developer
+  ```
+
+- `workspace-client <server-url> [folder ...]` - register this machine and its folders as a
+  workspace for a server, so a run on that server works in these folders.
+
+  ```sh
+  ragents workspace-client https://ragents.example.com ~/projects/demo
+  ```
+
+- `run <folder> "<task>"` - start the host if none answers, bind a new run to the folder and wait
+  until the turn is finished; the last line is always `run: <id>`.
+
+  ```sh
+  ragents run ~/projects/demo "Fix the type error in src/broken.ts"
+  ```
+
+- `send <run> "<text>"` - continue in the same run and wait the same way.
+
+  ```sh
+  ragents send 7f3c1e64-9a2b-4d11-8c30-1f5e9a77c001 "Now add a test for it"
+  ```
+
+- `journal <run> [--tools]` - read the history of a run without a server; `--tools` shows the tool
+  calls instead of the conversation.
+
+  ```sh
+  ragents journal 7f3c1e64-9a2b-4d11-8c30-1f5e9a77c001 --tools
+  ```
+
+- `stop <run>` - cancel the running turn, `stop --host` stops the remembered host process.
+
+  ```sh
+  ragents stop 7f3c1e64-9a2b-4d11-8c30-1f5e9a77c001
+  ```
+
+## Requirements
+
+- Node 22 (>= 22.19.0). No git, no pnpm, no build step.
+- `dotnet` (.NET 10 SDK) for the C# diagnostics through Roslyn and the F# diagnostics through FSAC;
+  without it TypeScript diagnostics still work.
+- Model access: either `OPENROUTER_API_KEY` in the environment, or `ragents connect <server-url>`
+  against a RAgents server that relays the models.
+
+## Documentation
+
+The specification, the operations guide, the profile and plugin reference and the homepage live in
+the repository: https://github.com/SchlenkR/RAgents
+
+## License
+
+Licensed under the PolyForm Shield License 1.0.0: use, including commercial use, is permitted;
+offering it as a competing product or service is not. See LICENSE.

package/apps/server/agent-home/settings.json

@@ -0,0 +1,3 @@
+{
+  "defaultProvider": "openrouter"
+}

package/apps/server/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@aicontainer/server",
+  "private": true,
+  "type": "module",
+  "exports": {
+    "./tests/*": "./tests/*",
+    "./*": "./src/*"
+  },
+  "scripts": {
+    "dev": "tsx watch src/main.ts",
+    "start": "tsx src/main.ts",
+    "test": "PRODUCT_PROFILE=core node --import tsx --test tests/*.test.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@aicontainer/agent": "workspace:*",
+    "@aicontainer/ai": "workspace:*",
+    "@aicontainer/ragents": "workspace:*",
+    "@aicontainer/workspace-executor": "workspace:*",
+    "handlebars": "^4.7.9",
+    "tsx": "^4.20.0",
+    "typebox": "^1.3.13",
+    "vscode-jsonrpc": "^9.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "typescript": "^5.8.0"
+  }
+}

package/apps/server/src/access-projection.ts

@@ -0,0 +1,97 @@
+import { emptyUsage, type AccessContext, type JsonValue, type PluginState, type RunView } from "@aicontainer/ragents";
+import type { ChatEvent, Message } from "./chat-events.js";
+import type { ActorConversations } from "./ragents/actor-chat-history.js";
+
+const record = (value: JsonValue | undefined): Record<string, JsonValue | undefined> | undefined =>
+  value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+
+const hiddenStates = new Set(["ragents.system-prompt", "ragents.model", "ragents.start-options"]);
+
+const visibleState = (entry: PluginState): PluginState | undefined => {
+  if (hiddenStates.has(entry.pluginId)) return undefined;
+  if (entry.pluginId === "ragents.actor-programs.invocations") return { ...entry, state: { version: 1, revision: entry.updatedAt } };
+  if (entry.pluginId !== "ragents.actor-programs") return entry;
+  const state = record(entry.state);
+  const program = state?.program ? record(state.program) : undefined;
+  if (!program) return entry;
+  const views = Array.isArray(program.views) ? program.views.map((value) => {
+    const view = record(value);
+    return view ? { id: view.id, key: view.key, title: view.title, visible: view.visible, placements: view.placements } : value;
+  }) : [];
+  return { ...entry, state: {
+    version: 1,
+    program: {
+      name: program.name,
+      title: program.title,
+      actorId: program.actorId,
+      actorHandle: program.actorHandle,
+      revision: program.revision,
+      views,
+    },
+  } };
+};
+
+export const accessibleRunView = (view: RunView, access: AccessContext): RunView => access.can("runs.inspect") ? view : {
+  ...view,
+  actors: view.actors.map((actor) => actor.kind === "human" ? { ...actor, grants: [] } : {
+    ...actor,
+    ...(actor.kind === "agent" ? { prompt: "" } : {}),
+    execution: {
+      driver: actor.execution.driver.kind === "agent" ? { kind: "agent", config: { provider: "", model: "" } } : actor.execution.driver,
+      workspacePath: null,
+      turnTimeoutMs: null,
+    },
+    grants: [],
+    toolNames: [],
+    openedToolNames: [],
+    usage: emptyUsage(),
+    lifecycle: actor.lifecycle.kind === "stopped" ? { ...actor.lifecycle, reason: "Beendet" } : actor.lifecycle,
+  }),
+  inputs: view.inputs.map((input) => ({ ...input, content: input.enqueuedBy === view.ownerId && input.presentation !== "background" ? input.content : "",
+    lifecycle: input.lifecycle.kind === "discarded" ? { ...input.lifecycle, reason: "Verworfen" } : input.lifecycle,
+  })),
+  turns: view.turns.map((turn) => ({ ...turn, usage: emptyUsage(), toolCalls: [], reason: turn.reason ? "Die Verarbeitung wurde beendet." : null })),
+  subscriptions: [],
+  pluginStates: view.pluginStates.flatMap((entry) => {
+    const state = visibleState(entry);
+    return state ? [state] : [];
+  }),
+};
+
+export const accessibleChatEvent = (event: ChatEvent, access: AccessContext): ChatEvent | undefined => {
+  if (access.can("runs.inspect")) return event;
+  if (event.kind === "status" && event.startup?.status === "failed") return {
+    ...event,
+    startup: { status: "failed", message: "Der Start konnte nicht abgeschlossen werden. Bitte wende Dich an den zuständigen Betreuer." },
+  };
+  const trace = access.can("runs.trace");
+  if (event.kind === "thinking") return trace ? event : { kind: "thinking", delta: "", at: event.at };
+  if (event.kind === "tool") return trace ? event : { kind: "tool", id: event.id, name: "", arguments: "", at: event.at };
+  if (event.kind === "tool-result") return trace ? event : { kind: "tool-result", id: event.id, result: "", isError: event.isError };
+  if (event.kind === "system") return { ...event, text: "Hinweis zur Verarbeitung. Bei Fragen wende Dich an den zuständigen Agenten." };
+  if (event.kind !== "extension") return event;
+  if (hiddenStates.has(event.pluginId)) return undefined;
+  if (event.pluginId === "ragents.actor-programs" || event.pluginId === "ragents.actor-programs.invocations") return undefined;
+  return event;
+};
+
+const visibleMessage = (message: Message, actorId: string, trace: boolean): Message[] => {
+  if (message.role === "system" || message.role === "assistant" && message.sender !== actorId) return [];
+  if (trace && (message.role === "thinking" || message.role === "tool")) return [message];
+  if (message.role === "thinking") return [{ key: message.key, role: "thinking", sender: message.sender, text: "", closed: message.closed, at: message.at }];
+  if (message.role === "tool") return [{
+    key: message.key, role: "tool", sender: message.sender, text: "", closed: message.closed, at: message.at,
+    ...(message.tool ? { tool: {
+      id: message.tool.id, name: "", arguments: "",
+      ...(message.tool.result === undefined ? {} : { result: "" }),
+      ...(message.tool.isError === undefined ? {} : { isError: message.tool.isError }),
+    } } : {}),
+  }];
+  return [message];
+};
+
+export const accessibleActorConversations = (history: ActorConversations, access: AccessContext): ActorConversations =>
+  access.can("runs.inspect") ? history : {
+    revision: history.revision,
+    actors: Object.fromEntries(Object.entries(history.actors).map(([id, messages]) => [id, messages.flatMap((message) => visibleMessage(message, id, access.can("runs.trace")))])),
+  };

package/apps/server/src/access-service.ts

@@ -0,0 +1,22 @@
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import type { IncomingMessage } from "node:http";
+
+const token = randomBytes(32).toString("hex");
+
+export const accessServiceToken = (): string => token;
+
+export const profileAccessCookieName = (productId: string | undefined, profile: string | undefined): string => {
+  if (!productId || !profile) throw new Error("Die Benutzeranmeldung benötigt PRODUCT_ID und PRODUCT_PROFILE");
+  return `${productId}-${profile}-user`;
+};
+
+export const isAccessServiceRequest = (request: IncomingMessage, url: URL): boolean => {
+  const address = request.socket.remoteAddress;
+  if (address !== "127.0.0.1" && address !== "::1" && address !== "::ffff:127.0.0.1") return false;
+  if (url.pathname !== "/rpc" && url.pathname !== "/rpc/stream" && !url.pathname.startsWith("/help/")) return false;
+  const offered = request.headers.authorization;
+  if (!offered?.startsWith("Bearer ")) return false;
+  const value = Buffer.from(offered.slice(7));
+  const expected = Buffer.from(token);
+  return value.length === expected.length && timingSafeEqual(value, expected);
+};

package/apps/server/src/access-session.ts

@@ -0,0 +1,204 @@
+import { createHash, randomBytes, scrypt, scryptSync, timingSafeEqual } from "node:crypto";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { ACCESS_TOKEN_QUERY, type AccessSnapshot, type AccessUser } from "@aicontainer/ragents";
+import type { ResolvedProfileUser } from "./config-file.js";
+import { PayloadTooLargeError, readJsonBody, writeJson } from "./plugin-support/http.js";
+
+export interface AccessSessionOptions {
+  users?: readonly ResolvedProfileUser[];
+  anonymousUser?: AccessUser;
+  cookieName: string;
+  sessionTtlMs?: number;
+  now?: () => number;
+}
+
+interface PasswordRecord {
+  user: AccessUser;
+  salt: Buffer;
+  hash: Buffer;
+}
+
+interface LoginSession {
+  user: AccessUser;
+  expiresAt: number;
+  responses: Set<ServerResponse>;
+  timer: ReturnType<typeof setTimeout>;
+}
+
+const derivePassword = (password: string, salt: Buffer): Promise<Buffer> => new Promise((resolve, reject) => {
+  scrypt(password, salt, 32, (error, key) => error ? reject(error) : resolve(key));
+});
+
+const digestOf = (token: string): Buffer => createHash("sha256").update(token).digest();
+
+export const isSameOriginRequest = (request: IncomingMessage): boolean => {
+  if (request.headers["sec-fetch-site"] === "cross-site") return false;
+  const origin = request.headers.origin;
+  if (!origin) return true;
+  try {
+    const parsed = new URL(origin);
+    return ["http:", "https:"].includes(parsed.protocol) && parsed.host === request.headers.host;
+  } catch {
+    return false;
+  }
+};
+
+export const createAccessSessionManager = (options: AccessSessionOptions) => {
+  if (!/^[A-Za-z0-9_-]+$/.test(options.cookieName)) throw new Error("Ungültiger Name für das Anmeldungscookie");
+  if (options.users?.length === 0) throw new Error("Eine aktivierte Anmeldung braucht mindestens einen Benutzer");
+  if (options.users && options.anonymousUser) throw new Error("Benutzeranmeldung und anonymer Zugang schließen einander aus");
+  const enabled = options.users !== undefined;
+  const now = options.now ?? Date.now;
+  const sessionTtlMs = options.sessionTtlMs ?? 12 * 60 * 60 * 1000;
+  if (!Number.isSafeInteger(sessionTtlMs) || sessionTtlMs < 1 || sessionTtlMs > 2_147_483_647) {
+    throw new Error("Ungültige Gültigkeitsdauer für Anmeldungen");
+  }
+  const passwords = new Map<string, PasswordRecord>();
+  // Persönliche Token liegen nur als SHA-256 im Speicher; der Vergleich läuft zeitkonstant über alle Einträge.
+  const personalTokens: Array<{ digest: Buffer; user: AccessUser }> = [];
+  for (const entry of options.users ?? []) {
+    if (passwords.has(entry.id)) throw new Error(`Doppelter Benutzer: ${entry.id}`);
+    const salt = randomBytes(16);
+    const user = Object.freeze({ id: entry.id, label: entry.label, rights: Object.freeze([...entry.rights]),
+      ...(entry.startEntries ? { startEntries: Object.freeze([...entry.startEntries]) } : {}),
+    });
+    passwords.set(entry.id, { user, salt, hash: scryptSync(entry.password, salt, 32) });
+    if (entry.token === undefined) continue;
+    const digest = digestOf(entry.token);
+    if (personalTokens.some((known) => timingSafeEqual(known.digest, digest))) throw new Error(`Der Token von Benutzer ${entry.id} gehört bereits einem anderen Benutzer`);
+    personalTokens.push({ digest, user });
+  }
+  const dummySalt = randomBytes(16);
+  const dummyHash = randomBytes(32);
+  const sessions = new Map<string, LoginSession>();
+  const wellFormed = (token: string | undefined): string | undefined => token !== undefined && /^[A-Za-z0-9_-]{43}$/.test(token) ? token : undefined;
+  // Clients ohne Cookie (VS-Code-Erweiterung, ihre iframes) senden den Token als Bearer; GET-Abrufe ohne Header (Ereignisstrom, Frames) als Abfrageparameter.
+  const tokenFor = (request: IncomingMessage): string | undefined => {
+    const authorization = request.headers.authorization;
+    if (authorization !== undefined) return wellFormed(/^Bearer (.+)$/.exec(authorization)?.[1]);
+    const offered = request.method === "GET" ? new URL(request.url ?? "/", "http://localhost").searchParams.get(ACCESS_TOKEN_QUERY) : null;
+    if (offered !== null) return wellFormed(offered);
+    const matches = (request.headers.cookie ?? "").split(";").map((part) => part.trim())
+      .filter((part) => part.startsWith(`${options.cookieName}=`));
+    if (matches.length !== 1) return undefined;
+    return wellFormed(matches[0]!.slice(options.cookieName.length + 1));
+  };
+  // Ein persönlicher Token gilt nur als Bearer oder, bei GET, als Abfrageparameter; nie als Cookie.
+  const offeredToken = (request: IncomingMessage): string | undefined => {
+    const authorization = request.headers.authorization;
+    if (authorization !== undefined) return /^Bearer (.+)$/.exec(authorization)?.[1];
+    if (request.method !== "GET") return undefined;
+    return new URL(request.url ?? "/", "http://localhost").searchParams.get(ACCESS_TOKEN_QUERY) ?? undefined;
+  };
+  const personalUserFor = (request: IncomingMessage): AccessUser | undefined => {
+    if (personalTokens.length === 0) return undefined;
+    const offered = offeredToken(request);
+    if (!offered || offered.length > 512) return undefined;
+    const digest = digestOf(offered);
+    return personalTokens.find((known) => timingSafeEqual(known.digest, digest))?.user;
+  };
+  const invalidate = (token: string): void => {
+    const session = sessions.get(token);
+    if (!session) return;
+    sessions.delete(token);
+    clearTimeout(session.timer);
+    for (const response of session.responses) response.destroy();
+    session.responses.clear();
+  };
+  const sessionFor = (request: IncomingMessage): LoginSession | undefined => {
+    const token = tokenFor(request);
+    if (!token) return undefined;
+    const session = sessions.get(token);
+    if (session && session.expiresAt <= now()) {
+      invalidate(token);
+      return undefined;
+    }
+    return session;
+  };
+  const snapshot = (request: IncomingMessage): AccessSnapshot => ({
+    enabled,
+    user: enabled ? personalUserFor(request) ?? sessionFor(request)?.user ?? null : options.anonymousUser ?? null,
+  });
+  const cookie = (request: IncomingMessage, token: string, age: number): string =>
+    `${options.cookieName}=${token}; Path=/; HttpOnly; SameSite=Lax; Max-Age=${age}`
+    + ((request.socket as { encrypted?: boolean }).encrypted ? "; Secure" : "");
+  const handle = async (request: IncomingMessage, response: ServerResponse, url: URL): Promise<boolean> => {
+    if (!["/api/access", "/api/access/login", "/api/access/logout"].includes(url.pathname)) return false;
+    const expected = url.pathname === "/api/access" ? "GET" : "POST";
+    if (request.method !== expected) {
+      response.setHeader("Allow", expected);
+      writeJson(response, 405, { error: "Methode nicht erlaubt" });
+      return true;
+    }
+    if (expected === "GET") {
+      writeJson(response, 200, snapshot(request));
+      return true;
+    }
+    if (!isSameOriginRequest(request)) {
+      writeJson(response, 403, { error: "Anmeldung und Abmeldung sind nur von derselben Website möglich" });
+      return true;
+    }
+    if (!enabled) {
+      writeJson(response, 409, { error: "Die Anmeldung ist in diesem Profil ausgeschaltet" });
+      return true;
+    }
+    if (url.pathname === "/api/access/logout") {
+      const token = tokenFor(request);
+      if (token) invalidate(token);
+      response.setHeader("Set-Cookie", cookie(request, "", 0));
+      writeJson(response, 200, { enabled, user: null } satisfies AccessSnapshot);
+      return true;
+    }
+    if (request.headers["content-type"]?.split(";")[0]?.trim() !== "application/json") {
+      writeJson(response, 415, { error: "Die Anmeldung benötigt application/json" });
+      return true;
+    }
+    try {
+      const credentials = await readJsonBody(request, (body) => {
+        if (!body || typeof body !== "object" || Array.isArray(body)) throw new Error("Benutzerkennung und Passwort fehlen");
+        const value = body as Record<string, unknown>;
+        if (Object.keys(value).some((key) => key !== "id" && key !== "password")
+          || typeof value.id !== "string" || !value.id || value.id.length > 64
+          || typeof value.password !== "string" || !value.password || value.password.length > 2048) {
+          throw new Error("Benutzerkennung und Passwort sind ungültig");
+        }
+        return { id: value.id, password: value.password };
+      }, "Die Anmeldung enthält kein gültiges JSON", 4096);
+      const record = passwords.get(credentials.id);
+      const hash = await derivePassword(credentials.password, record?.salt ?? dummySalt);
+      const matches = timingSafeEqual(hash, record?.hash ?? dummyHash);
+      if (!record || !matches) {
+        writeJson(response, 401, { error: "Benutzerkennung oder Passwort stimmen nicht" });
+        return true;
+      }
+      const previous = tokenFor(request);
+      if (previous) invalidate(previous);
+      const token = randomBytes(32).toString("base64url");
+      const timer = setTimeout(() => invalidate(token), sessionTtlMs);
+      timer.unref();
+      sessions.set(token, { user: record.user, expiresAt: now() + sessionTtlMs, responses: new Set(), timer });
+      response.setHeader("Set-Cookie", cookie(request, token, Math.ceil(sessionTtlMs / 1000)));
+      writeJson(response, 200, { enabled, user: record.user } satisfies AccessSnapshot);
+    } catch (error) {
+      if (!request.aborted && !response.destroyed) {
+        writeJson(response, error instanceof PayloadTooLargeError ? 413 : 400, {
+          error: error instanceof PayloadTooLargeError ? "Die Anmeldedaten sind zu groß" : "Die Anmeldedaten sind ungültig",
+        });
+      }
+    }
+    return true;
+  };
+  const track = (request: IncomingMessage, response: ServerResponse): void => {
+    const session = sessionFor(request);
+    if (!session) return;
+    session.responses.add(response);
+    const release = () => {
+      session.responses.delete(response);
+      response.off("close", release);
+      response.off("finish", release);
+    };
+    response.once("close", release);
+    response.once("finish", release);
+  };
+  return { enabled, snapshot, handle, track, close: () => { for (const token of sessions.keys()) invalidate(token); } };
+};