yorck-mcp 0.1.0

package/src/lib/srp.ts

@@ -0,0 +1,248 @@
+// AWS Cognito SRP (Secure Remote Password) auth, implemented for Cloudflare Workers
+// using only standards-track Web APIs (BigInt, crypto.subtle, TextEncoder).
+//
+// Reference: https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-authentication-flow.html
+// AWS uses SRP-6a with N = 3072-bit prime, g = 2, hash = SHA-256, plus a custom HKDF.
+
+// 3072-bit prime N from RFC 5054 group 14? AWS uses RFC 5054 group N (a specific 3072-bit prime).
+// This is the well-known prime used by AWS Cognito.
+const N_HEX =
+  "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E08" +
+  "8A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B" +
+  "302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9" +
+  "A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE6" +
+  "49286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8" +
+  "FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D" +
+  "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C" +
+  "180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF695581718" +
+  "3995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D" +
+  "04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7D" +
+  "B3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D226" +
+  "1AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200C" +
+  "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFC" +
+  "E0FD108E4B82D120A93AD2CAFFFFFFFFFFFFFFFF";
+
+const G_HEX = "2";
+
+const N = BigInt("0x" + N_HEX);
+const G = BigInt("0x" + G_HEX);
+
+const enc = new TextEncoder();
+
+function hexToBytes(hex: string): Uint8Array {
+  if (hex.length % 2) hex = "0" + hex;
+  const out = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < out.length; i++) out[i] = parseInt(hex.substr(i * 2, 2), 16);
+  return out;
+}
+
+function bytesToHex(bytes: Uint8Array): string {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+function bigIntToHex(n: bigint): string {
+  let h = n.toString(16);
+  if (h.length % 2) h = "0" + h;
+  return h;
+}
+
+// Pad hex with a leading 00 if its top bit is set, per Cognito's serialization quirks.
+function padHex(h: string): string {
+  if (h.length % 2) h = "0" + h;
+  if (parseInt(h[0], 16) >= 8) h = "00" + h;
+  return h;
+}
+
+async function sha256(data: Uint8Array): Promise<Uint8Array> {
+  return new Uint8Array(await crypto.subtle.digest("SHA-256", data as BufferSource));
+}
+
+async function hexHash(hex: string): Promise<string> {
+  return bytesToHex(await sha256(hexToBytes(hex)));
+}
+
+function concatBytes(...arrs: Uint8Array[]): Uint8Array {
+  const total = arrs.reduce((n, a) => n + a.length, 0);
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const a of arrs) {
+    out.set(a, off);
+    off += a.length;
+  }
+  return out;
+}
+
+async function hmacSha256(key: Uint8Array, msg: Uint8Array): Promise<Uint8Array> {
+  const k = await crypto.subtle.importKey("raw", key as BufferSource, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  return new Uint8Array(await crypto.subtle.sign("HMAC", k, msg as BufferSource));
+}
+
+// AWS-specific HKDF using SHA-256, no info salt — exact same as Cognito's PasswordAuthenticationKey impl.
+async function awsHkdf(ikm: Uint8Array, salt: Uint8Array): Promise<Uint8Array> {
+  const prk = await hmacSha256(salt, ikm);
+  const info = enc.encode("Caldera Derived Key");
+  const t1 = await hmacSha256(prk, concatBytes(info, new Uint8Array([1])));
+  return t1.slice(0, 16);
+}
+
+// Constant-time-ish modular exponentiation for BigInt (left-to-right binary).
+function modPow(base: bigint, exp: bigint, mod: bigint): bigint {
+  let result = 1n;
+  base = base % mod;
+  let e = exp;
+  while (e > 0n) {
+    if (e & 1n) result = (result * base) % mod;
+    e >>= 1n;
+    base = (base * base) % mod;
+  }
+  return result;
+}
+
+function randomBigInt(byteLen: number): bigint {
+  const buf = new Uint8Array(byteLen);
+  crypto.getRandomValues(buf);
+  return BigInt("0x" + bytesToHex(buf));
+}
+
+export interface CognitoTokens {
+  IdToken: string;
+  AccessToken: string;
+  RefreshToken: string;
+  ExpiresIn: number;
+  TokenType: string;
+}
+
+const KCal = (async () => {
+  // k = H(N || g)
+  return BigInt("0x" + (await hexHash(padHex(N_HEX) + padHex(G_HEX))));
+})();
+
+export async function cognitoSrpLogin(args: {
+  region: string;
+  userPoolId: string;
+  clientId: string;
+  username: string;
+  password: string;
+}): Promise<CognitoTokens> {
+  const { region, userPoolId, clientId, username, password } = args;
+  const cognitoUrl = `https://cognito-idp.${region}.amazonaws.com/`;
+  const userPoolName = userPoolId.split("_")[1];
+
+  // 1) Generate client SRP_a, SRP_A.
+  const a = randomBigInt(128);
+  const A = modPow(G, a, N);
+  if (A % N === 0n) throw new Error("SRP_A is zero");
+  const srpA = padHex(bigIntToHex(A));
+
+  // 2) InitiateAuth USER_SRP_AUTH
+  const initRes = await fetch(cognitoUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-amz-json-1.1",
+      "X-Amz-Target": "AWSCognitoIdentityProviderService.InitiateAuth",
+    },
+    body: JSON.stringify({
+      AuthFlow: "USER_SRP_AUTH",
+      ClientId: clientId,
+      AuthParameters: { USERNAME: username, SRP_A: srpA },
+    }),
+  });
+  if (!initRes.ok) throw new Error(`InitiateAuth ${initRes.status}: ${await initRes.text()}`);
+  const init = (await initRes.json()) as {
+    ChallengeName?: string;
+    ChallengeParameters: {
+      USER_ID_FOR_SRP: string;
+      SRP_B: string;
+      SALT: string;
+      SECRET_BLOCK: string;
+    };
+  };
+
+  if (init.ChallengeName !== "PASSWORD_VERIFIER") {
+    throw new Error(`Unexpected challenge: ${init.ChallengeName}`);
+  }
+  const userIdForSrp = init.ChallengeParameters.USER_ID_FOR_SRP;
+  const srpB = init.ChallengeParameters.SRP_B;
+  const salt = init.ChallengeParameters.SALT;
+  const secretBlock = init.ChallengeParameters.SECRET_BLOCK;
+  const B = BigInt("0x" + srpB);
+  if (B % N === 0n) throw new Error("SRP_B is zero");
+
+  // 3) u = H(A || B)
+  const u = BigInt("0x" + (await hexHash(padHex(bigIntToHex(A)) + padHex(srpB))));
+  if (u === 0n) throw new Error("u is zero");
+
+  // 4) x = H(salt || H(poolName || username || ':' || password))
+  const innerHashHex = bytesToHex(
+    await sha256(enc.encode(`${userPoolName}${userIdForSrp}:${password}`))
+  );
+  const xHex = await hexHash(padHex(salt) + innerHashHex);
+  const x = BigInt("0x" + xHex);
+
+  // 5) k = H(N || g) ; gx = g^x ; intermediate = (B - k * gx) mod N ; S = (intermediate)^(a + u*x) mod N
+  const k = await KCal;
+  const gx = modPow(G, x, N);
+  let intermediate = (B - ((k * gx) % N) + N * 2n) % N; // ensure positive
+  const S = modPow(intermediate, a + u * x, N);
+
+  // 6) HKDF derive password authentication key
+  const hkdf = await awsHkdf(hexToBytes(padHex(bigIntToHex(S))), hexToBytes(padHex(bigIntToHex(u))));
+
+  // 7) Build PASSWORD_CLAIM_SIGNATURE = HMAC(hkdf, poolName || userIdForSrp || secretBlock || timestamp)
+  const now = new Date();
+  // AWS expects: "EEE MMM d HH:mm:ss UTC yyyy" (English locale, single-digit day no zero pad)
+  const days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+  const months = [
+    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+  ];
+  const pad2 = (n: number) => String(n).padStart(2, "0");
+  const timestamp =
+    `${days[now.getUTCDay()]} ${months[now.getUTCMonth()]} ${now.getUTCDate()} ` +
+    `${pad2(now.getUTCHours())}:${pad2(now.getUTCMinutes())}:${pad2(now.getUTCSeconds())} UTC ` +
+    `${now.getUTCFullYear()}`;
+
+  const secretBlockBytes = Uint8Array.from(atob(secretBlock), (c) => c.charCodeAt(0));
+  const claimMsg = concatBytes(
+    enc.encode(userPoolName),
+    enc.encode(userIdForSrp),
+    secretBlockBytes,
+    enc.encode(timestamp)
+  );
+  const sig = await hmacSha256(hkdf, claimMsg);
+  const sigB64 = btoa(String.fromCharCode(...sig));
+
+  // 8) RespondToAuthChallenge
+  const respRes = await fetch(cognitoUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-amz-json-1.1",
+      "X-Amz-Target": "AWSCognitoIdentityProviderService.RespondToAuthChallenge",
+    },
+    body: JSON.stringify({
+      ClientId: clientId,
+      ChallengeName: "PASSWORD_VERIFIER",
+      ChallengeResponses: {
+        USERNAME: userIdForSrp,
+        PASSWORD_CLAIM_SECRET_BLOCK: secretBlock,
+        PASSWORD_CLAIM_SIGNATURE: sigB64,
+        TIMESTAMP: timestamp,
+      },
+    }),
+  });
+  if (!respRes.ok) throw new Error(`RespondToAuthChallenge ${respRes.status}: ${await respRes.text()}`);
+  const resp = (await respRes.json()) as {
+    AuthenticationResult?: {
+      IdToken: string;
+      AccessToken: string;
+      RefreshToken: string;
+      ExpiresIn: number;
+      TokenType: string;
+    };
+    ChallengeName?: string;
+  };
+  if (!resp.AuthenticationResult) {
+    throw new Error(`Auth failed: ${JSON.stringify(resp)}`);
+  }
+  return resp.AuthenticationResult;
+}

package/src/lib/tz.ts

@@ -0,0 +1,75 @@
+// Yorck stores session times with a fixed +01:00 offset year-round (CMS bug).
+// The local part of the timestamp is the actual Berlin local time. Re-anchor.
+
+const BERLIN_TZ = "Europe/Berlin";
+
+function berlinOffsetMinutes(date: Date): number {
+  const fmt = new Intl.DateTimeFormat("en-US", {
+    timeZone: BERLIN_TZ,
+    timeZoneName: "longOffset",
+  });
+  const parts = fmt.formatToParts(date);
+  const tz = parts.find((p) => p.type === "timeZoneName")?.value ?? "GMT+01:00";
+  const m = tz.match(/GMT([+-])(\d{1,2})(?::(\d{2}))?/);
+  if (!m) return 60;
+  const sign = m[1] === "+" ? 1 : -1;
+  const h = parseInt(m[2], 10);
+  const min = m[3] ? parseInt(m[3], 10) : 0;
+  return sign * (h * 60 + min);
+}
+
+// Convert Yorck-formatted "2026-05-08T17:30:00+01:00" to a proper Berlin-local ISO string.
+// We treat the local clock face as Berlin local time and apply the correct offset.
+export function fixYorckTime(yorckIso: string): string {
+  const m = yorckIso.match(/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})/);
+  if (!m) return yorckIso;
+  const [, y, mo, d, h, mi, s] = m;
+  // Build a tentative Date in UTC representing the wall-clock time
+  const tentative = new Date(Date.UTC(+y, +mo - 1, +d, +h, +mi, +s));
+  const offsetMin = berlinOffsetMinutes(tentative);
+  const sign = offsetMin >= 0 ? "+" : "-";
+  const abs = Math.abs(offsetMin);
+  const oh = String(Math.floor(abs / 60)).padStart(2, "0");
+  const om = String(abs % 60).padStart(2, "0");
+  return `${y}-${mo}-${d}T${h}:${mi}:${s}${sign}${oh}:${om}`;
+}
+
+export function addMinutesIso(berlinIso: string, minutes: number): string {
+  const d = new Date(berlinIso);
+  d.setUTCMinutes(d.getUTCMinutes() + minutes);
+  // Re-emit in Berlin local
+  const off = berlinOffsetMinutes(d);
+  const local = new Date(d.getTime() + off * 60_000);
+  const y = local.getUTCFullYear();
+  const mo = String(local.getUTCMonth() + 1).padStart(2, "0");
+  const da = String(local.getUTCDate()).padStart(2, "0");
+  const h = String(local.getUTCHours()).padStart(2, "0");
+  const mi = String(local.getUTCMinutes()).padStart(2, "0");
+  const s = String(local.getUTCSeconds()).padStart(2, "0");
+  const sign = off >= 0 ? "+" : "-";
+  const abs = Math.abs(off);
+  const oh = String(Math.floor(abs / 60)).padStart(2, "0");
+  const om = String(abs % 60).padStart(2, "0");
+  return `${y}-${mo}-${da}T${h}:${mi}:${s}${sign}${oh}:${om}`;
+}
+
+export function nowBerlinIso(): string {
+  const now = new Date();
+  const off = berlinOffsetMinutes(now);
+  const local = new Date(now.getTime() + off * 60_000);
+  const y = local.getUTCFullYear();
+  const mo = String(local.getUTCMonth() + 1).padStart(2, "0");
+  const da = String(local.getUTCDate()).padStart(2, "0");
+  const h = String(local.getUTCHours()).padStart(2, "0");
+  const mi = String(local.getUTCMinutes()).padStart(2, "0");
+  const s = String(local.getUTCSeconds()).padStart(2, "0");
+  const sign = off >= 0 ? "+" : "-";
+  const abs = Math.abs(off);
+  const oh = String(Math.floor(abs / 60)).padStart(2, "0");
+  const om = String(abs % 60).padStart(2, "0");
+  return `${y}-${mo}-${da}T${h}:${mi}:${s}${sign}${oh}:${om}`;
+}
+
+export function todayBerlinDate(): string {
+  return nowBerlinIso().slice(0, 10);
+}

package/src/local-mcp.ts

@@ -0,0 +1,72 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import type { Env } from "./types.ts";
+import { registerPrivateBookingTools, registerPublicTools } from "./tool-registration.ts";
+
+const DEFAULTS = {
+  PREFERRED_CINEMAS: "babylon-kreuzberg,delphi-filmpalast,delphi-lux,filmtheater-am-friedrichshain,kant-kino,kino-international,neues-off,odeon,passage,rollberg,yorck",
+  DEFAULT_FORMATS: "OmeU,OV,OmU",
+  COGNITO_USER_POOL: "eu-central-1_TIusy2VuG",
+  COGNITO_CLIENT_ID: "4m9hc0qk59mvcb4hfd6lep1262",
+  COGNITO_REGION: "eu-central-1",
+  VISTA_BASE: "https://uq8lgoj7z2.execute-api.eu-central-1.amazonaws.com/production/api/vista",
+  YORCK_AUTH_BASE: "https://rbfmu7cs19.execute-api.eu-central-1.amazonaws.com/production",
+  YORCK_BASE: "https://www.yorck.de",
+  PUBLIC_BASE_URL: "https://yorck-mcp.isiklimahir.workers.dev",
+};
+
+type KvRecord = { value: string; expiresAt?: number };
+
+class MemoryKv {
+  private store = new Map<string, KvRecord>();
+
+  async get(key: string, type?: "text" | "json" | "arrayBuffer" | "stream") {
+    const record = this.store.get(key);
+    if (!record) return null;
+    if (record.expiresAt && Date.now() > record.expiresAt) {
+      this.store.delete(key);
+      return null;
+    }
+    if (type === "json") return JSON.parse(record.value);
+    if (type === "arrayBuffer") return new TextEncoder().encode(record.value).buffer;
+    return record.value;
+  }
+
+  async put(key: string, value: string | ArrayBuffer | ArrayBufferView | ReadableStream, options?: { expirationTtl?: number }) {
+    if (typeof value !== "string") throw new Error("local MCP MemoryKv only supports string values");
+    this.store.set(key, {
+      value,
+      expiresAt: options?.expirationTtl ? Date.now() + options.expirationTtl * 1000 : undefined,
+    });
+  }
+}
+
+function envFromProcess(): Env {
+  return {
+    CACHE: new MemoryKv() as unknown as KVNamespace,
+    MCP_OBJECT: undefined as unknown as DurableObjectNamespace,
+    PUBLIC_MCP_OBJECT: undefined as unknown as DurableObjectNamespace,
+    BROWSER: undefined as unknown as Fetcher,
+    PREFERRED_CINEMAS: process.env.YORCK_PREFERRED_CINEMAS || DEFAULTS.PREFERRED_CINEMAS,
+    DEFAULT_FORMATS: process.env.YORCK_DEFAULT_FORMATS || DEFAULTS.DEFAULT_FORMATS,
+    COGNITO_USER_POOL: process.env.COGNITO_USER_POOL || DEFAULTS.COGNITO_USER_POOL,
+    COGNITO_CLIENT_ID: process.env.COGNITO_CLIENT_ID || DEFAULTS.COGNITO_CLIENT_ID,
+    COGNITO_REGION: process.env.COGNITO_REGION || DEFAULTS.COGNITO_REGION,
+    VISTA_BASE: process.env.VISTA_BASE || DEFAULTS.VISTA_BASE,
+    YORCK_AUTH_BASE: process.env.YORCK_AUTH_BASE || DEFAULTS.YORCK_AUTH_BASE,
+    YORCK_BASE: process.env.YORCK_BASE || DEFAULTS.YORCK_BASE,
+    PUBLIC_BASE_URL: process.env.PUBLIC_BASE_URL || DEFAULTS.PUBLIC_BASE_URL,
+    YORCK_EMAIL: process.env.YORCK_EMAIL,
+    YORCK_PASSWORD: process.env.YORCK_PASSWORD,
+    YORCK_UNLIMITED_CARD: process.env.YORCK_UNLIMITED_CARD,
+    YORCK_MCP_AUTH_TOKEN: process.env.YORCK_MCP_AUTH_TOKEN,
+  };
+}
+
+export async function runLocalMcp(): Promise<void> {
+  const env = envFromProcess();
+  const server = new McpServer({ name: "yorck-local", version: "0.1.0" });
+  registerPublicTools(server, env);
+  registerPrivateBookingTools(server, env);
+  await server.connect(new StdioServerTransport());
+}

package/src/mcp.ts

@@ -0,0 +1,30 @@
+import { McpAgent } from "agents/mcp";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { Env } from "./types.ts";
+import { registerPrivateBookingTools, registerPublicTools } from "./tool-registration.ts";
+
+export { registerPrivateBookingTools, registerPublicTools } from "./tool-registration.ts";
+
+export class PublicYorckMcp extends McpAgent<Env> {
+  server = new McpServer({
+    name: "yorck-public",
+    version: "0.1.0",
+  });
+
+  async init() {
+    registerPublicTools(this.server, this.env);
+  }
+}
+
+export class YorckMcp extends McpAgent<Env> {
+  server = new McpServer({
+    name: "yorck-private",
+    version: "0.1.0",
+  });
+
+  async init() {
+    const env = this.env;
+    registerPublicTools(this.server, env);
+    registerPrivateBookingTools(this.server, env);
+  }
+}

package/src/tool-registration.ts

@@ -0,0 +1,228 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import type { Env, Showtime } from "./types.ts";
+import { searchShowtimes, findFilmsByQuery, getComingSoon } from "./yorck/films.ts";
+import { getCinemas } from "./yorck/cinemas.ts";
+import { getSeatPlan, renderSeatPlanSvg } from "./yorck/seats.ts";
+import { reserveUnlimited, cancelOrder, commitOrder } from "./yorck/booking.ts";
+import { showtimeToIcs } from "./lib/ics.ts";
+import { nowBerlinIso } from "./lib/tz.ts";
+
+const FilmFiltersSchema = {
+  when: z
+    .union([
+      z.enum(["now", "tonight", "tomorrow", "weekend", "week"]),
+      z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+    ])
+    .optional()
+    .describe("'tonight', 'tomorrow', 'weekend', 'week', or YYYY-MM-DD"),
+  cinemas: z
+    .array(z.string())
+    .optional()
+    .describe("cinema slugs, e.g. ['rollberg','delphi-lux']. Defaults to configured preferred cinemas."),
+  formats: z
+    .array(z.string())
+    .optional()
+    .describe("'OmeU' (English subs), 'OV' (no subs), 'OmU' (German subs), 'DF' (German dub). Default excludes DF."),
+  preferEnglish: z.boolean().optional().describe("bias toward OmeU > OV > OmU when sorting"),
+  genres: z.array(z.string()).optional().describe("e.g. ['Drama','Documentary']"),
+  fskMax: z.number().int().min(0).max(18).optional(),
+  runtimeMax: z.number().int().min(30).max(300).optional(),
+  after: z.string().regex(/^\d{1,2}:\d{2}$/).optional().describe("HH:MM, e.g. '18:00'"),
+  before: z.string().regex(/^\d{1,2}:\d{2}$/).optional(),
+  yorckPick: z.boolean().optional(),
+  district: z.array(z.string()).optional(),
+  query: z.string().optional().describe("text search across title and tagline"),
+};
+
+function project(showtimes: Showtime[], limit = 50): { now: string; count: number; truncated: boolean; showtimes: Showtime[] } {
+  return {
+    now: nowBerlinIso(),
+    count: showtimes.length,
+    truncated: showtimes.length > limit,
+    showtimes: showtimes.slice(0, limit),
+  };
+}
+
+function publicBaseUrl(env: Env): string {
+  return (env.PUBLIC_BASE_URL || "https://yorck-mcp.isiklimahir.workers.dev").replace(/\/$/, "");
+}
+
+export function registerPublicTools(server: McpServer, env: Env) {
+  server.tool(
+    "whats_on",
+    "Search public Yorck showtimes in Berlin with filters. Use this for everyday 'what is playing tonight / this weekend' queries.",
+    FilmFiltersSchema,
+    async (args) => {
+      const out = await searchShowtimes(env, args);
+      return {
+        content: [{ type: "text" as const, text: JSON.stringify(project(out), null, 2) }],
+      };
+    }
+  );
+
+  server.tool(
+    "find_film",
+    "Search for a Yorck film by title, director, or tagline. Returns matches with their slug for showtimes.",
+    { query: z.string().min(2), limit: z.number().int().min(1).max(20).optional() },
+    async ({ query, limit }) => {
+      const matches = await findFilmsByQuery(env, query, limit ?? 5);
+      return { content: [{ type: "text" as const, text: JSON.stringify(matches, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    "showtimes",
+    "All upcoming sessions for a specific film, optionally filtered by cinema, format, or date.",
+    {
+      slug: z.string().describe("film slug from find_film"),
+      cinemas: z.array(z.string()).optional(),
+      formats: z.array(z.string()).optional(),
+      date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+    },
+    async ({ slug, cinemas, formats, date }) => {
+      const out = (await searchShowtimes(env, { cinemas, formats, date, query: undefined })).filter(
+        (s) => s.slug === slug
+      );
+      return { content: [{ type: "text" as const, text: JSON.stringify(project(out), null, 2) }] };
+    }
+  );
+
+  server.tool(
+    "coming_soon",
+    "Films opening at Yorck in the coming weeks.",
+    {},
+    async () => {
+      const upcoming = await getComingSoon(env);
+      return { content: [{ type: "text" as const, text: JSON.stringify(upcoming.slice(0, 30), null, 2) }] };
+    }
+  );
+
+  server.tool(
+    "cinemas",
+    "List Yorck cinemas with slugs, addresses, districts, and public metadata.",
+    {},
+    async () => {
+      const cinemas = await getCinemas(env);
+      return { content: [{ type: "text" as const, text: JSON.stringify(cinemas, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    "seat_map",
+    "Returns the public seat plan for a session as an inline SVG image plus visible row and seat IDs. This tool does not reserve or book seats.",
+    {
+      sessionId: z.string().regex(/^\d{4}-\d+$/).describe("Yorck session id, e.g. '1003-5724'"),
+    },
+    async ({ sessionId }) => {
+      const [cinemaVistaId, sessionNum] = sessionId.split("-");
+      const cinema = await (async () => {
+        const all = await getCinemas(env);
+        return all.find((c) => c.vistaId === cinemaVistaId);
+      })();
+      if (!cinema) throw new Error(`unknown cinema for session ${sessionId}`);
+      const plan = await getSeatPlan(env, cinemaVistaId, sessionNum);
+      const svg = renderSeatPlanSvg(plan, {
+        title: `${cinema.name}`,
+        subtitle: `Session ${sessionId}`,
+      });
+      const rows = (plan.SeatLayoutData.Areas[0]?.Rows ?? []).map((row) => ({
+        physicalName: row.PhysicalName,
+        rowIndex: row.RowIndexZeroBased,
+        availableIds: (row.Seats ?? []).filter((seat) => seat.Status === 0).map((seat) => seat.Id),
+      }));
+      const dataUrl = "data:image/svg+xml;base64," + btoa(svg);
+      return {
+        content: [
+          { type: "text" as const, text: JSON.stringify({ sessionId, cinema: cinema.name, rows }, null, 2) },
+          { type: "image" as const, data: dataUrl, mimeType: "image/svg+xml" },
+        ],
+      };
+    }
+  );
+
+  server.tool(
+    "add_to_calendar",
+    "Generate an .ics calendar event for a public Yorck showtime.",
+    {
+      sessionId: z.string().regex(/^\d{4}-\d+$/),
+      slug: z.string().describe("film slug"),
+    },
+    async ({ sessionId, slug }) => {
+      const all = await searchShowtimes(env, { cinemas: undefined, formats: ["OmeU", "OV", "OmU", "DF"] });
+      const s = all.find((x) => x.sessionId === sessionId && x.slug === slug);
+      if (!s) throw new Error("session not found in current showtimes");
+      const cinemas = await getCinemas(env);
+      const cinema = cinemas.find((c) => c.slug === s.cinemaSlug);
+      const ics = showtimeToIcs(s, cinema?.address);
+      const downloadUrl = `${publicBaseUrl(env)}/v1/calendar/${encodeURIComponent(sessionId)}.ics?slug=${encodeURIComponent(slug)}`;
+      return {
+        content: [{
+          type: "text" as const,
+          text: JSON.stringify({
+            downloadUrl,
+            filename: `${slug}-${sessionId}.ics`,
+            note: "Open or import the downloadUrl in Apple Calendar, Google Calendar, Outlook, or any calendar app. The raw ICS is included below.",
+            ics,
+          }, null, 2),
+        }],
+      };
+    }
+  );
+}
+
+export function registerPrivateBookingTools(server: McpServer, env: Env) {
+  server.tool(
+    "book_session",
+    "Private tool. Reserve and book a specific seat using your Yorck Unlimited subscription. Pass cinemaSlug + sessionId + rowLabel + seatId. Will reserve, validate as Unlimited (€0), and if dryRun=false, commit. Default dryRun=true reserves only, returns preview, and does not finalize.",
+    {
+      sessionId: z.string().regex(/^\d{4}-\d+$/),
+      cinemaSlug: z.string(),
+      rowLabel: z.string().describe("e.g. '16' (the PhysicalName from seat_map)"),
+      seatId: z.string().describe("e.g. '17' (the seat Id from seat_map)"),
+      dryRun: z.boolean().default(true),
+    },
+    async ({ sessionId, cinemaSlug, rowLabel, seatId, dryRun }) => {
+      const r = await reserveUnlimited(env, { sessionId, cinemaSlug, rowLabel, seatId });
+      const summary = {
+        reserved: true,
+        approved: r.approved,
+        ticketTypeCode: r.ticketTypeCode,
+        orderTotal: r.order.orderTotalValueInCents / 100,
+        expiresAt: r.expiresAt,
+        userSessionId: r.order.userSessionId,
+        cinema: cinemaSlug,
+        seat: { row: rowLabel, seat: seatId },
+        film: r.order.sessions[0]?.filmTitle,
+        start: r.order.sessions[0]?.startTime,
+      };
+      if (dryRun) {
+        await cancelOrder(env, r.order.userSessionId);
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `DRY-RUN ${summary.approved ? "✓" : "✗"} ${JSON.stringify(summary, null, 2)}\n(seat hold released for safety; call again with dryRun=false to actually book)`,
+            },
+          ],
+        };
+      }
+      const result = await commitOrder(env, r.order.userSessionId);
+      return {
+        content: [
+          { type: "text" as const, text: `Booked! ${JSON.stringify({ ...summary, commit: result }, null, 2)}` },
+        ],
+      };
+    }
+  );
+
+  server.tool(
+    "cancel_booking",
+    "Private tool. Release a held order by userSessionId. Use this if you want to abandon a reservation before it auto-expires.",
+    { userSessionId: z.string() },
+    async ({ userSessionId }) => {
+      await cancelOrder(env, userSessionId);
+      return { content: [{ type: "text" as const, text: `cancelled ${userSessionId}` }] };
+    }
+  );
+}