@manta-eu/horns-server 0.1.2 → 0.1.3

package/dist/agents-proxy.d.ts

@@ -20,6 +20,8 @@ export type ProxyToMantaAgentsArgs = {
     request: Request;
     agentsUrl?: string;
     session?: MantaSessionState;
+    /** The host's own session cookie names, where it has them. Defaults to Horns'. */
+    sessionCookiePrefix?: string;
 };
 export declare function agentsPathUrl(agentsUrl: string, pathAndQuery: string): URL;
 export declare function agentsUpstreamUrl(agentsUrl: string, requestUrl: string): URL;

package/dist/agents-proxy.js

@@ -72,15 +72,15 @@ export function buildAgentsProxyRequest(args) {
     return { url, init };
 }
 function sessionCookiesToWrite(args) {
-    const { request, session, clearSession } = args;
+    const { request, session, clearSession, sessionCookiePrefix: prefix } = args;
     const secure = requestIsSecure(request.url);
     if (clearSession)
-        return clearSessionSetCookies({ secure });
+        return clearSessionSetCookies({ secure }, prefix);
     if (!sessionsDiffer(session.before, session.after))
         return [];
     return isPresent(Object.keys(session.after.upstreamCookies))
-        ? sessionSetCookies(session.after, { secure })
-        : clearSessionSetCookies({ secure });
+        ? sessionSetCookies(session.after, { secure }, prefix)
+        : clearSessionSetCookies({ secure }, prefix);
 }
 // Agents' cookies never reach the browser: they are folded into this worker's own session cookies.
 function withSessionCookies(args) {
@@ -97,7 +97,7 @@ function withSessionCookies(args) {
     return new Response(response.body, { status: response.status, statusText: response.statusText, headers });
 }
 export async function proxyToMantaAgents(args) {
-    const { request, agentsUrl, session } = args;
+    const { request, agentsUrl, session, sessionCookiePrefix } = args;
     const decision = await evaluateProxyPolicy(request);
     if (!decision.allow) {
         return Response.json({ error: decision.error }, { status: decision.status });
@@ -127,5 +127,6 @@ export async function proxyToMantaAgents(args) {
         request,
         session: { before, after: captureUpstreamCookies(before, response) },
         clearSession: new URL(request.url).pathname === logoutPath,
+        ...(isPresent(sessionCookiePrefix) ? { sessionCookiePrefix } : {}),
     });
 }

package/dist/auth-routes.d.ts

@@ -6,7 +6,7 @@ export declare const logoutPath = "/logout";
 export declare const forwardedOriginHeader = "x-manta-forwarded-origin";
 export declare function safeRedirect(raw: string | null | undefined): string;
 export declare function logoutResponseReturningTo(response: Response, request: Request): Response;
-export declare function localSignOutResponse(request: Request): Response;
+export declare function localSignOutResponse(request: Request, sessionCookiePrefix?: string): Response;
 export declare const authUnavailableMessage = "Manta could not be reached, so signing in is not possible right now.";
 export declare function authUnavailableResponse(request: Request): Response;
 export declare function loginRequestWithMarker(request: Request): Request;

package/dist/auth-routes.js

@@ -52,10 +52,10 @@ function rewrittenLogoutLocation(location, returnTo) {
     keycloak.searchParams.set("post_logout_redirect_uri", returnTo);
     return keycloak.toString();
 }
-export function localSignOutResponse(request) {
+export function localSignOutResponse(request, sessionCookiePrefix) {
     const url = new URL(request.url);
     const headers = new Headers({ location: url.origin + safeRedirect(url.searchParams.get("redirect")) });
-    for (const cookie of clearSessionSetCookies({ secure: requestIsSecure(request.url) })) {
+    for (const cookie of clearSessionSetCookies({ secure: requestIsSecure(request.url) }, sessionCookiePrefix)) {
         headers.append("set-cookie", cookie);
     }
     return new Response(null, { status: 302, headers });

package/dist/dev-session.d.ts

@@ -1,5 +1,7 @@
 import { type MantaSessionState } from "./session.ts";
 export type DevSessionEnv = {
     DEV_AGENTS_COOKIE?: string;
+    /** A host that signs people in itself names its own session cookies here. Defaults to Horns' own. */
+    HORNS_SESSION_COOKIE_PREFIX?: string;
 };
 export declare function requestSession(request: Request, env: DevSessionEnv): MantaSessionState | undefined;

package/dist/dev-session.js

@@ -1,11 +1,11 @@
 import { isPresent } from "@manta-eu/lib/present";
-import { agentsJwtCookieName, parseCookieHeader, readSessionState } from "./session.js";
+import { agentsJwtCookieName, parseCookieHeader, readSessionState, sessionCookiePrefixOf, } from "./session.js";
 const loopbackHosts = new Set(["localhost", "127.0.0.1", "[::1]"]);
 // HireManta staging will not send a sign-in back to localhost, so `pnpm dev` can borrow a staging agents session
 // captured by `dev:borrow-session`. It stands in only for requests to this machine that carry no Horns session
 // yet (agents' token refreshes then land in a real one), and production builds drop it with import.meta.env.DEV.
 export function requestSession(request, env) {
-    const session = readSessionState(request.headers.get("cookie"));
+    const session = readSessionState(request.headers.get("cookie"), sessionCookiePrefixOf(env));
     if (isPresent(session) || !import.meta.env.DEV || !isPresent(env.DEV_AGENTS_COOKIE))
         return session;
     if (!loopbackHosts.has(new URL(request.url).hostname))

package/dist/index.d.ts

@@ -11,7 +11,7 @@ export { datastoreAccessFor, datastoreAccessUnavailableMessage, datastoreNotGran
 export { agentsSparqlSelect } from "./sparql-select.ts";
 export { agentsSparqlUpdate, WriteRefusedError } from "./sparql-update.ts";
 export { criticModelFromEnv, studioModelFromEnv, type StudioModelEnv, type StudioModelResult } from "./llm.ts";
-export { isSignedIn, sessionSetCookies, type MantaSessionState } from "./session.ts";
+export { badSessionCookiePrefixMessage, isSignedIn, sessionCookiePrefix, sessionCookiePrefixOf, sessionSetCookies, type MantaSessionState, } from "./session.ts";
 export { requestSession, type DevSessionEnv } from "./dev-session.ts";
 export { hornTemplatePath, renderHornDocument } from "./render-document.ts";
 export { sentryOptionsForDeploy } from "./sentry.ts";

package/dist/index.js

@@ -12,7 +12,7 @@ export { agentsSparqlUpdate, WriteRefusedError } from "./sparql-update.js";
 // Also its own entry, `@manta-eu/horns-server/llm`: building a model client must not drag in the render
 // path, which is JSX and which a Node script cannot load.
 export { criticModelFromEnv, studioModelFromEnv } from "./llm.js";
-export { isSignedIn, sessionSetCookies } from "./session.js";
+export { badSessionCookiePrefixMessage, isSignedIn, sessionCookiePrefix, sessionCookiePrefixOf, sessionSetCookies, } from "./session.js";
 export { requestSession } from "./dev-session.js";
 export { hornTemplatePath, renderHornDocument } from "./render-document.js";
 export { sentryOptionsForDeploy } from "./sentry.js";

package/dist/session.d.ts

@@ -1,4 +1,5 @@
 export declare const agentsJwtCookieName = "auth";
+/** What Horns names its own session cookies. A host with a session of its own overrides it; see `sessionCookiePrefixOf`. */
 export declare const sessionCookiePrefix = "mh_session";
 export declare const maxSessionCookieChunks = 8;
 export type MantaSessionState = {
@@ -12,9 +13,17 @@ export declare function isForwardableCookie(name: string, value: string): boolea
 export declare function parseCookieHeader(header: string | null | undefined): Record<string, string>;
 export declare function serializeCookie(name: string, value: string, attributes: CookieAttributes): string;
 export declare function requestIsSecure(requestUrl: string): boolean;
-export declare function sessionSetCookies(state: MantaSessionState, attributes: CookieAttributes): string[];
-export declare function clearSessionSetCookies(attributes: CookieAttributes): string[];
-export declare function readSessionState(cookieHeader: string | null | undefined): MantaSessionState | undefined;
+export declare function sessionSetCookies(state: MantaSessionState, attributes: CookieAttributes, prefix?: string): string[];
+export declare function clearSessionSetCookies(attributes: CookieAttributes, prefix?: string): string[];
+export declare const badSessionCookiePrefixMessage = "HORNS_SESSION_COOKIE_PREFIX is not a cookie name \u2014 use RFC 6265 token characters.";
+/**
+ * Which cookies these routes read and write. A host that signs people in itself names its own prefix, or the
+ * worker looks for a Horns session the host never wrote and answers every call "not signed in".
+ */
+export declare function sessionCookiePrefixOf(env: {
+    HORNS_SESSION_COOKIE_PREFIX?: string;
+}): string;
+export declare function readSessionState(cookieHeader: string | null | undefined, prefix?: string): MantaSessionState | undefined;
 export declare function isSignedIn(state: MantaSessionState | undefined): boolean;
 export declare function upstreamCookieHeader(state: MantaSessionState): string;
 export declare function setCookieHeadersOf(response: Response): string[];

package/dist/session.js

@@ -1,6 +1,7 @@
 import { isPresent } from "@manta-eu/lib/present";
 import { isRecord } from "@manta-eu/horns";
 export const agentsJwtCookieName = "auth";
+/** What Horns names its own session cookies. A host with a session of its own overrides it; see `sessionCookiePrefixOf`. */
 export const sessionCookiePrefix = "mh_session";
 export const maxSessionCookieChunks = 8;
 const chunkSize = 3500;
@@ -57,23 +58,37 @@ function chunk(value) {
         chunks.push(value.slice(i, i + chunkSize));
     return chunks;
 }
-export function sessionSetCookies(state, attributes) {
+export function sessionSetCookies(state, attributes, prefix = sessionCookiePrefix) {
     const chunks = chunk(encodeJson(state));
     if (chunks.length > maxSessionCookieChunks) {
         throw new Error(`Horns session does not fit in ${maxSessionCookieChunks} cookies.`);
     }
-    const written = chunks.map((value, index) => serializeCookie(`${sessionCookiePrefix}${index}`, value, attributes));
-    const cleared = Array.from({ length: maxSessionCookieChunks - chunks.length }, (_unused, offset) => serializeCookie(`${sessionCookiePrefix}${chunks.length + offset}`, "", { ...attributes, maxAge: 0 }));
+    const written = chunks.map((value, index) => serializeCookie(`${prefix}${index}`, value, attributes));
+    const cleared = Array.from({ length: maxSessionCookieChunks - chunks.length }, (_unused, offset) => serializeCookie(`${prefix}${chunks.length + offset}`, "", { ...attributes, maxAge: 0 }));
     return [...written, ...cleared];
 }
-export function clearSessionSetCookies(attributes) {
-    return Array.from({ length: maxSessionCookieChunks }, (_unused, index) => serializeCookie(`${sessionCookiePrefix}${index}`, "", { ...attributes, maxAge: 0 }));
-}
-export function readSessionState(cookieHeader) {
+export function clearSessionSetCookies(attributes, prefix = sessionCookiePrefix) {
+    return Array.from({ length: maxSessionCookieChunks }, (_unused, index) => serializeCookie(`${prefix}${index}`, "", { ...attributes, maxAge: 0 }));
+}
+export const badSessionCookiePrefixMessage = "HORNS_SESSION_COOKIE_PREFIX is not a cookie name — use RFC 6265 token characters.";
+/**
+ * Which cookies these routes read and write. A host that signs people in itself names its own prefix, or the
+ * worker looks for a Horns session the host never wrote and answers every call "not signed in".
+ */
+export function sessionCookiePrefixOf(env) {
+    const configured = env.HORNS_SESSION_COOKIE_PREFIX;
+    if (!isPresent(configured))
+        return sessionCookiePrefix;
+    // `${prefix}0` has to be a cookie name; a prefix that is not one would be dropped silently by the browser.
+    if (!cookieNamePattern.test(`${configured}0`))
+        throw new Error(badSessionCookiePrefixMessage);
+    return configured;
+}
+export function readSessionState(cookieHeader, prefix = sessionCookiePrefix) {
     const jar = parseCookieHeader(cookieHeader);
     let encoded = "";
     for (let index = 0; index < maxSessionCookieChunks; index += 1) {
-        const part = jar[`${sessionCookiePrefix}${index}`];
+        const part = jar[`${prefix}${index}`];
         if (!isPresent(part))
             break;
         encoded += part;

package/dist/worker.js

@@ -10,6 +10,7 @@ import { studioRoutes } from "./studio-routes.js";
 import { contentSecurityPolicy } from "./csp.js";
 import { criticModelFromEnv } from "./llm.js";
 import { requestSession } from "./dev-session.js";
+import { sessionCookiePrefixOf } from "./session.js";
 import { asJsonRequest, followedLink, noPageToOpen, signInFirst } from "./entity-links.js";
 import { isSignedIn } from "./session.js";
 import { sentryOptionsForDeploy } from "./sentry.js";
@@ -59,6 +60,7 @@ export function createHornsApp({ shapes, componentApi, typecheck, criticModel =
         return proxyToMantaAgents({
             request,
             agentsUrl: c.env.MANTA_AGENTS_URL,
+            sessionCookiePrefix: sessionCookiePrefixOf(c.env),
             ...(isPresent(session) ? { session } : {}),
         });
     }
@@ -80,9 +82,9 @@ export function createHornsApp({ shapes, componentApi, typecheck, criticModel =
         const response = await agentsProxy(c);
         // 5xx: agents never dropped our cookies — sign out locally instead.
         if (response.status >= 500)
-            return localSignOutResponse(c.req.raw);
+            return localSignOutResponse(c.req.raw, sessionCookiePrefixOf(c.env));
         return logoutResponseReturningTo(response, c.req.raw);
-    }, c.req.raw, localSignOutResponse));
+    }, c.req.raw, (request) => localSignOutResponse(request, sessionCookiePrefixOf(c.env))));
     const signedOutLoginStatus = { valid: false, canSwitchDatastore: false, allowedModels: [] };
     app.get("/api/login", async (c) => {
         const denied = sameOriginDeniedResponse(c.req.raw);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manta-eu/horns-server",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "The Manta Horns worker as a library: Hono routes a Cloudflare host mounts on its own app.",
   "license": "MIT",
   "repository": {
@@ -49,8 +49,8 @@
     "sparqljs": "^3.7.4",
     "typescript": "^5.9.0",
     "zod": "^4.5.4",
-    "@manta-eu/horns": "0.1.2",
-    "@manta-eu/horns-kit": "0.1.2"
+    "@manta-eu/horns": "0.1.3",
+    "@manta-eu/horns-kit": "0.1.3"
   },
   "devDependencies": {
     "@cloudflare/vite-plugin": "1.47.0",