src/worker.js

const MAX_FILE_BYTES = 1024 * 1024;
const MAX_REQUEST_BYTES = MAX_FILE_BYTES + 32 * 1024;
const MAX_HARNESS_REQUEST_BYTES = 24 * 1024;
const MAX_SITE_EVENT_BYTES = 2048;
const CONSENT_VERSION = "client-handoff-md-v0-2026-05-14";
const DEFAULT_HARNESS_MODEL = "gpt-5.5";
const HERO_EXPERIMENT_ID = "homepage-hero-2026-05-23";
const HERO_VARIANTS = ["A_control", "B_offer_first", "C_proof_first"];
const SITE_EVENTS = ["hero_impression", "hero_cta_click", "cta_click"];
const SITE_EVENT_TARGETS = [
  "",
  "contact_fit_call",
  "intake_start",
  "hero_choose_path",
  "hero_fit",
  "hero_fit_call",
  "hero_product",
  "hero_proof",
  "nav_fit_call",
  "router_agent_workflow",
  "router_muenztelefon",
  "router_orientation",
  "choose_path",
  "contact_fit_call_nav",
  "contact_one_workflow",
  "fit",
  "product",
  "proof",
];
const VIEWPORT_CLASSES = ["mobile", "tablet", "desktop"];

const HARNESS_PROFILES = {
  claude: {
    label: "Claude Code",
    route: "Claude-Code-Onboarding",
    focus: "projektnahe Codearbeit, Debugging, kontextreiches Arbeiten",
    guidance: [
      "Scope vor Ausfuehrung festlegen.",
      "Plan pruefen lassen, bevor Edits passieren.",
      "Kleine Diffs, keine Secrets, Tests oder Evidence verlangen.",
      "Mensch bleibt Merge- und Abnahmeautoritaet.",
    ],
  },
  codex: {
    label: "Codex",
    route: "Codex-Onboarding",
    focus: "bounded Worker fuer klar definierte Coding-Aufgaben",
    guidance: [
      "Aufgabe eng formulieren.",
      "Dateien oder Module nennen, wenn bekannt.",
      "Akzeptanzkriterien und Abschlusspruefung geben.",
      "Output als Patch, Report oder naechste Entscheidung verlangen.",
    ],
  },
  hermes: {
    label: "Hermes",
    route: "Hermes-Onboarding",
    focus: "profilbasierte Agentensteuerung, Rollenarbeit und HAI-Control-Plane-Denken",
    guidance: [
      "Profilrolle und Nicht-Rolle trennen.",
      "Session-Kontext nicht mit langfristiger Memory verwechseln.",
      "Fanout klein halten und mit Stop-Regel beenden.",
      "Owner-Packet statt unkontrollierter Orchestrierung erzeugen.",
    ],
  },
  unknown: {
    label: "General HAI Triage",
    route: "General-HAI-Triage",
    focus: "Klaerung, welches Harness oder welche Arbeitsform passt",
    guidance: [
      "Erst Problem, Ziel und Grenze klaeren.",
      "Keine Tool-Empfehlung vor Problemverstaendnis.",
      "Eine kleine kontrollierbare naechste Handlung definieren.",
      "Spezialroute erst waehlen, wenn der Tool-Kontext klar ist.",
    ],
  },
};

export default {
  async fetch(request, env) {
    const url = new URL(request.url);

    if (url.pathname === "/api/client-handoff-upload") {
      return handleClientHandoffUpload(request, env);
    }

    if (url.pathname === "/api/harness-check/chat") {
      return handleHarnessCheckChat(request, env);
    }

    if (url.pathname === "/api/site-event") {
      return handleSiteEvent(request, env);
    }

    if (request.method === "GET" && (url.pathname === "/" || url.pathname === "/index.html")) {
      return handleHomepage(request, env);
    }

    if (request.method === "GET" && (url.pathname === "/intake" || url.pathname.startsWith("/intake/"))) {
      return serveIntakeAsset(request, env, url);
    }

    return env.ASSETS.fetch(request);
  },
};

async function handleHomepage(request, env) {
  const url = new URL(request.url);
  const previewVariant = url.searchParams.get("hero_variant");
  const existingVariant = parseCookies(request.headers.get("cookie") || "").haiHeroVariant;
  const variant = HERO_VARIANTS.includes(previewVariant)
    ? previewVariant
    : HERO_VARIANTS.includes(existingVariant)
      ? existingVariant
      : HERO_VARIANTS[cryptoRandomIndex(HERO_VARIANTS.length)];

  const response = await env.ASSETS.fetch(request);
  const headers = new Headers(response.headers);
  headers.append("Vary", "Cookie");

  if (!HERO_VARIANTS.includes(previewVariant)) {
    headers.append("Set-Cookie", `haiHeroVariant=${variant}; Max-Age=2592000; Path=/; SameSite=Lax; Secure`);
  }

  const contentType = headers.get("content-type") || "";
  if (!contentType.toLowerCase().includes("text/html")) {
    return new Response(response.body, {
      status: response.status,
      statusText: response.statusText,
      headers,
    });
  }

  const html = await response.text();
  const injected = html.replace(
    "<html lang=\"en\">",
    `<html lang="en" data-hero-experiment="${HERO_EXPERIMENT_ID}" data-hero-variant="${variant}">`,
  );

  return new Response(injected, {
    status: response.status,
    statusText: response.statusText,
    headers,
  });
}

function serveIntakeAsset(request, env, url) {
  let assetPath = url.pathname;
  if (assetPath === "/intake" || assetPath === "/intake/") {
    assetPath = "/APP/intake/index.html";
  } else if (assetPath.startsWith("/intake/")) {
    assetPath = `/APP/intake/${assetPath.slice("/intake/".length)}`;
  }

  const assetUrl = new URL(assetPath, url.origin);
  return env.ASSETS.fetch(new Request(assetUrl, request));
}

async function handleSiteEvent(request, env) {
  if (request.method === "OPTIONS") {
    return json({ ok: true }, 204, corsHeaders());
  }

  if (request.method !== "POST") {
    return json({ error: "Only POST site events are accepted." }, 405, {
      Allow: "POST, OPTIONS",
      ...corsHeaders(),
    });
  }

  const contentLength = Number(request.headers.get("content-length") || 0);
  if (contentLength > MAX_SITE_EVENT_BYTES) {
    return json({ error: "Site event is too large." }, 413, corsHeaders());
  }

  const contentType = request.headers.get("content-type") || "";
  if (!contentType.toLowerCase().includes("application/json")) {
    return json({ error: "Site events must be JSON." }, 415, corsHeaders());
  }

  let payload;
  try {
    payload = await request.json();
  } catch (error) {
    return json({ error: "Site event JSON could not be read." }, 400, corsHeaders());
  }

  const event = normalizeSiteEvent(payload);
  if (!event.ok) {
    return json({ error: event.error }, 400, corsHeaders());
  }

  if (env.HAI_SITE_EVENTS) {
    env.HAI_SITE_EVENTS.writeDataPoint({
      indexes: [event.value.experiment_id],
      blobs: [
        event.value.variant,
        event.value.event,
        event.value.target,
        event.value.path,
        event.value.language,
        event.value.viewport_class,
      ],
      doubles: [Date.now()],
    });
  }

  return json({
    ok: true,
    recorded: Boolean(env.HAI_SITE_EVENTS),
  }, 200, corsHeaders());
}

async function handleHarnessCheckChat(request, env) {
  if (request.method === "OPTIONS") {
    return json({ ok: true }, 204, corsHeaders());
  }

  if (request.method !== "POST") {
    return json({ error: "Only POST chat requests are accepted." }, 405, {
      Allow: "POST, OPTIONS",
      ...corsHeaders(),
    });
  }

  const contentLength = Number(request.headers.get("content-length") || 0);
  if (contentLength > MAX_HARNESS_REQUEST_BYTES) {
    return json({ error: "Harness check request is too large." }, 413, corsHeaders());
  }

  const contentType = request.headers.get("content-type") || "";
  if (!contentType.toLowerCase().includes("application/json")) {
    return json({ error: "Harness check requests must be JSON." }, 415, corsHeaders());
  }

  let payload;
  try {
    payload = await request.json();
  } catch (error) {
    return json({ error: "Harness check JSON could not be read." }, 400, corsHeaders());
  }

  const session = normalizeHarnessSession(payload);
  const profile = HARNESS_PROFILES[session.harness] || HARNESS_PROFILES.unknown;

  if (hasSecretLikeText(JSON.stringify(payload))) {
    return json({
      ok: true,
      route: profile.route,
      blocked: true,
      reply: "Stop: Das sieht nach Secret, Token, Passwort oder API-Key aus. Ich verarbeite das in V0 nicht weiter. Beschreibe die Stelle abstrakt: welches System, welche Grenze, welcher Fehler. Keine Werte, keine Keys, keine privaten Dumps.",
    }, 200, corsHeaders());
  }

  if (!env.OPENAI_API_KEY) {
    return json({
      error: "OpenAI API key is not configured.",
      route: profile.route,
    }, 503, corsHeaders());
  }

  const mode = session.mode === "summary" ? "summary" : "chat";
  const instructions = buildHarnessInstructions(profile, mode);
  const input = buildHarnessInput(session, profile, mode);
  const model = trimMax(env.HAI_HARNESS_MODEL || env.OPENAI_MODEL || DEFAULT_HARNESS_MODEL, 80);

  let openaiResponse;
  try {
    openaiResponse = await fetch("https://api.openai.com/v1/responses", {
      method: "POST",
      headers: {
        "Authorization": `Bearer ${env.OPENAI_API_KEY}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        model,
        instructions,
        input,
        store: false,
        max_output_tokens: mode === "summary" ? 520 : 360,
      }),
    });
  } catch (error) {
    return json({
      error: "OpenAI request failed before a response was returned.",
      route: profile.route,
    }, 502, corsHeaders());
  }

  let data;
  try {
    data = await openaiResponse.json();
  } catch (error) {
    return json({
      error: "OpenAI response could not be read.",
      route: profile.route,
    }, 502, corsHeaders());
  }

  if (!openaiResponse.ok) {
    return json({
      error: "OpenAI request failed.",
      detail: trimMax(data?.error?.message || "Unknown OpenAI error.", 260),
      route: profile.route,
    }, 502, corsHeaders());
  }

  const text = extractOpenAIText(data);
  if (!text) {
    return json({
      error: "OpenAI response did not contain text.",
      route: profile.route,
    }, 502, corsHeaders());
  }

  return json({
    ok: true,
    mode,
    route: profile.route,
    harness: session.harness,
    reply: text,
    summaryReady: mode === "summary" || session.userMessageCount >= 4,
  }, 200, corsHeaders());
}

function normalizeHarnessSession(payload) {
  const rawHarness = trimMax(payload?.harness, 40);
  const rawLevel = trimMax(payload?.level, 40);
  const messages = Array.isArray(payload?.messages) ? payload.messages : [];

  return {
    mode: trimMax(payload?.mode, 20),
    harness: HARNESS_PROFILES[rawHarness] ? rawHarness : "unknown",
    level: ["beginner", "intermediate", "power"].includes(rawLevel) ? rawLevel : "intermediate",
    problem: trimMax(payload?.problem, 520) || "Noch nicht klar benannt",
    goal: trimMax(payload?.goal, 180) || "kontrollierter mit dem Harness arbeiten",
    constraints: normalizeStringList(payload?.constraints, 8, 80),
    userMessageCount: clampInteger(payload?.userMessageCount, 0, 10),
    messages: messages.slice(-12).map((message) => ({
      role: message?.role === "agent" ? "agent" : "user",
      text: trimMax(message?.text, 900),
    })).filter((message) => message.text),
  };
}

function normalizeStringList(value, maxItems, maxLength) {
  if (!Array.isArray(value)) return [];
  return value
    .slice(0, maxItems)
    .map((item) => trimMax(item, maxLength))
    .filter(Boolean);
}

function normalizeSiteEvent(payload) {
  const experimentId = trimMax(payload?.experiment_id, 80);
  const variant = trimMax(payload?.variant, 40);
  const event = trimMax(payload?.event, 40);
  const target = trimMax(payload?.target, 80);
  const path = normalizeSitePath(payload?.path);
  const language = normalizeLanguage(payload?.language);
  const viewportClass = trimMax(payload?.viewport_class, 20);

  if (experimentId !== HERO_EXPERIMENT_ID) {
    return { ok: false, error: "Unknown experiment." };
  }

  if (!HERO_VARIANTS.includes(variant)) {
    return { ok: false, error: "Unknown variant." };
  }

  if (!SITE_EVENTS.includes(event)) {
    return { ok: false, error: "Unknown event." };
  }

  if (!SITE_EVENT_TARGETS.includes(target)) {
    return { ok: false, error: "Unknown event target." };
  }

  if (!VIEWPORT_CLASSES.includes(viewportClass)) {
    return { ok: false, error: "Unknown viewport class." };
  }

  return {
    ok: true,
    value: {
      experiment_id: experimentId,
      variant,
      event,
      target,
      path,
      language,
      viewport_class: viewportClass,
    },
  };
}

function normalizeSitePath(value) {
  const path = trimMax(value, 120) || "/";
  if (!path.startsWith("/")) return "/";
  return path.split("?")[0].split("#")[0].replace(/[^a-zA-Z0-9/_-]+/g, "").slice(0, 120) || "/";
}

function normalizeLanguage(value) {
  const language = trimMax(value, 8).toLowerCase();
  if (language.startsWith("de")) return "de";
  return "en";
}

function clampInteger(value, min, max) {
  const number = Number.parseInt(value, 10);
  if (!Number.isFinite(number)) return min;
  return Math.max(min, Math.min(max, number));
}

function buildHarnessInstructions(profile, mode) {
  const task = mode === "summary"
    ? "Erzeuge ein kompaktes Session Packet."
    : "Fuehre die naechste Antwort in der begrenzten Onboarding-Session.";

  return [
    "Du bist der HAI Live Harness Onboarding Agent.",
    task,
    "Sprache: Deutsch, knapp, konkret, ohne Marketing-Floskeln.",
    "Du erklaerst, strukturierst und schlaegst vor. Du fuehrst nichts aus.",
    "Du nimmst keine Secrets, API Keys, Tokens, Passwoerter, privaten Repo-Dumps oder Accountdaten entgegen.",
    "Du forderst keinen Upload und keinen direkten Repo- oder Account-Zugriff an.",
    "Du gibst keine Rechts-, Finanz-, Medizin- oder Security-Expertenberatung.",
    "Ziel: Aus einem diffusen Agentenproblem wird ein sicherer, pruefbarer naechster Harness-Schritt.",
    `Route: ${profile.route}.`,
    `Harness-Fokus: ${profile.focus}.`,
    `Guidance: ${profile.guidance.join(" ")}`,
    mode === "summary"
      ? "Format: plain text mit Labels: Problem, Harness, Risiken, Empfehlung, Naechster Schritt, Verifikation, Kontakt-Hinweis. Keine Tabelle."
      : "Antwortformat: 2-4 kurze Absaetze. Stelle maximal eine Frage. Wenn genug Kontext da ist, fuehre zum Abschluss-Paket.",
  ].join("\n");
}

function buildHarnessInput(session, profile, mode) {
  const transcript = session.messages
    .map((message) => `${message.role === "agent" ? "Agent" : "User"}: ${message.text}`)
    .join("\n");

  return [
    `Modus: ${mode}`,
    `Harness: ${profile.label}`,
    `Route: ${profile.route}`,
    `Level: ${session.level}`,
    `Problem: ${session.problem}`,
    `Ziel: ${session.goal}`,
    `Grenzen: ${session.constraints.join(", ") || "keine angegeben"}`,
    `User-Nachrichten: ${session.userMessageCount}/10`,
    "",
    "Transkript:",
    transcript || "(noch kein User-Transkript)",
  ].join("\n");
}

function extractOpenAIText(data) {
  if (typeof data?.output_text === "string" && data.output_text.trim()) {
    return data.output_text.trim();
  }

  const parts = [];
  for (const item of data?.output || []) {
    for (const content of item?.content || []) {
      if (typeof content?.text === "string") {
        parts.push(content.text);
      }
    }
  }

  return parts.join("\n").trim();
}

function hasSecretLikeText(text) {
  return [
    /sk-[a-zA-Z0-9_-]{12,}/,
    /api[_-]?key\s*[:=]/i,
    /token\s*[:=]/i,
    /password\s*[:=]/i,
    /secret\s*[:=]/i,
  ].some((pattern) => pattern.test(text || ""));
}

async function handleClientHandoffUpload(request, env) {
  if (request.method === "OPTIONS") {
    return json({ ok: true }, 204, corsHeaders());
  }

  if (request.method !== "POST") {
    return json({ error: "Only POST uploads are accepted." }, 405, {
      Allow: "POST, OPTIONS",
      ...corsHeaders(),
    });
  }

  if (!env.HAI_CLIENT_HANDOFFS) {
    return json({ error: "Upload storage is not configured." }, 500);
  }

  const contentLength = Number(request.headers.get("content-length") || 0);
  if (contentLength > MAX_REQUEST_BYTES) {
    return json({ error: "Upload is too large. The Markdown file must be 1 MB or smaller." }, 413);
  }

  const contentType = request.headers.get("content-type") || "";
  if (!contentType.toLowerCase().includes("multipart/form-data")) {
    return json({ error: "Upload must be sent as multipart form data." }, 415);
  }

  let form;
  try {
    form = await request.formData();
  } catch (error) {
    return json({ error: "Upload form could not be read." }, 400);
  }

  const caseId = normalizeCaseId(readText(form, "caseId"));
  const customerName = trimMax(readText(form, "customerName"), 120);
  const customerEmail = trimMax(readText(form, "customerEmail"), 160);
  const contextNote = trimMax(readText(form, "contextNote"), 1000);
  const consent = form.get("consent") === "yes";
  const consentVersion = readText(form, "consentVersion") || CONSENT_VERSION;
  const files = form.getAll("handoffFile").filter(isFileLike);

  if (!caseId) {
    return json({ error: "Accepted case ID is required." }, 400);
  }

  if (!customerName) {
    return json({ error: "Name is required." }, 400);
  }

  if (!isEmailLike(customerEmail)) {
    return json({ error: "A valid customer email is required." }, 400);
  }

  if (!consent) {
    return json({ error: "Consent is required before uploading context." }, 400);
  }

  if (files.length !== 1) {
    return json({ error: "Upload exactly one Markdown file." }, 400);
  }

  const file = files[0];
  const originalFilename = trimMax(file.name || "context.md", 180);

  if (!originalFilename.toLowerCase().endsWith(".md")) {
    return json({ error: "Only .md files are accepted in this MVP." }, 415);
  }

  if (file.size <= 0) {
    return json({ error: "The Markdown file is empty." }, 400);
  }

  if (file.size > MAX_FILE_BYTES) {
    return json({ error: "The Markdown file must be 1 MB or smaller." }, 413);
  }

  const safeFilename = normalizeFilename(originalFilename);
  const uploadedAt = new Date().toISOString();
  const uploadId = crypto.randomUUID();
  const keyTimestamp = uploadedAt.replace(/[:.]/g, "-");
  const objectKey = `accepted-cases/${caseId}/${keyTimestamp}-${safeFilename}`;
  const metadataKey = `${objectKey}.metadata.json`;
  const body = await file.arrayBuffer();
  const sha256 = await sha256Hex(body);

  const metadata = {
    uploadId,
    caseId,
    uploadedAt,
    originalFilename,
    storedFilename: safeFilename,
    size: file.size,
    sha256,
    customerName,
    customerEmail,
    contextNote,
    consent: true,
    consentVersion,
    purpose: "Accepted HAI case preparation context",
    limits: "One Markdown file only. No raw .claude folder or agent-system folder.",
  };

  await env.HAI_CLIENT_HANDOFFS.put(objectKey, body, {
    httpMetadata: {
      contentType: "text/markdown; charset=utf-8",
      contentDisposition: `attachment; filename="${safeFilename}"`,
      cacheControl: "no-store",
    },
    customMetadata: {
      uploadId,
      caseId,
      uploadedAt,
      customerEmail,
      originalFilename,
      sha256,
      consentVersion,
    },
  });

  await env.HAI_CLIENT_HANDOFFS.put(metadataKey, JSON.stringify(metadata, null, 2), {
    httpMetadata: {
      contentType: "application/json; charset=utf-8",
      cacheControl: "no-store",
    },
  });

  return json({
    ok: true,
    uploadId,
    caseId,
    filename: safeFilename,
    size: file.size,
  }, 201);
}

function json(payload, status = 200, extraHeaders = {}) {
  return new Response(status === 204 ? null : JSON.stringify(payload), {
    status,
    headers: {
      "Content-Type": "application/json; charset=utf-8",
      "Cache-Control": "no-store",
      ...extraHeaders,
    },
  });
}

function corsHeaders() {
  return {
    "Access-Control-Allow-Methods": "POST, OPTIONS",
    "Access-Control-Allow-Headers": "Content-Type",
  };
}

function parseCookies(cookieHeader) {
  return Object.fromEntries(
    String(cookieHeader || "")
      .split(";")
      .map((part) => part.trim())
      .filter(Boolean)
      .map((part) => {
        const index = part.indexOf("=");
        if (index === -1) return [part, ""];
        return [part.slice(0, index), decodeURIComponent(part.slice(index + 1))];
      }),
  );
}

function cryptoRandomIndex(length) {
  const bytes = new Uint32Array(1);
  crypto.getRandomValues(bytes);
  return bytes[0] % length;
}

function readText(form, key) {
  const value = form.get(key);
  return typeof value === "string" ? value.trim() : "";
}

function trimMax(value, max) {
  return String(value || "").trim().slice(0, max);
}

function isFileLike(value) {
  return Boolean(
    value &&
      typeof value === "object" &&
      typeof value.name === "string" &&
      typeof value.size === "number" &&
      typeof value.arrayBuffer === "function",
  );
}

function normalizeCaseId(value) {
  return String(value || "")
    .trim()
    .toLowerCase()
    .replace(/[^a-z0-9._-]+/g, "-")
    .replace(/^-+|-+$/g, "")
    .slice(0, 80);
}

function normalizeFilename(value) {
  const base = String(value || "context.md").split(/[\\/]/).pop() || "context.md";
  const normalized = base
    .replace(/[^a-zA-Z0-9._-]+/g, "-")
    .replace(/-+/g, "-")
    .replace(/^-+|-+$/g, "")
    .slice(0, 120);

  if (!normalized) return "context.md";
  return normalized.toLowerCase().endsWith(".md") ? normalized : `${normalized}.md`;
}

function isEmailLike(value) {
  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
}

async function sha256Hex(buffer) {
  const digest = await crypto.subtle.digest("SHA-256", buffer);
  return [...new Uint8Array(digest)]
    .map((byte) => byte.toString(16).padStart(2, "0"))
    .join("");
}