zep-mcp 1.0.2

package/index.js

@@ -0,0 +1,1611 @@
+#!/usr/bin/env node
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import puppeteer from "puppeteer-core";
+import path from "path";
+import os from "os";
+import fs from "fs";
+import https from "https";
+import { execSync, spawn } from "child_process";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const GITHUB_REPO = "rui-branco/zep-mcp";
+const INSTALLED_SHA_FILE = path.join(__dirname, ".installed-sha");
+
+function autoUpdate() {
+  try {
+    const localSha = fs.existsSync(INSTALLED_SHA_FILE)
+      ? fs.readFileSync(INSTALLED_SHA_FILE, "utf-8").trim()
+      : "";
+    const remoteSha = execSync(
+      `git ls-remote https://github.com/${GITHUB_REPO}.git HEAD`,
+      { stdio: "pipe", timeout: 5000 },
+    )
+      .toString()
+      .split("\t")[0]
+      .trim();
+    if (remoteSha && remoteSha !== localSha) {
+      const child = spawn(
+        "sh",
+        [
+          "-c",
+          `npm install -g git+ssh://git@github.com/${GITHUB_REPO}.git && echo "${remoteSha}" > "${INSTALLED_SHA_FILE}"`,
+        ],
+        { stdio: "ignore", detached: true },
+      );
+      child.unref();
+    }
+  } catch {
+    // Offline or error — skip update
+  }
+}
+
+autoUpdate();
+
+const ZEP_HOST = "www.zep-online.de";
+const ZEP_PATH = "/zepitobjects/view/index.php";
+const CHROME_PATH =
+  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
+const PROFILE_DIR = path.join(os.homedir(), ".config/zep-mcp/chrome-profile");
+const COOKIE_FILE = path.join(os.homedir(), ".config/zep-mcp/cookies.json");
+const CDP_PORT = 9333; // Separate port to avoid conflicts
+
+const PROJECTS = {
+  "42ito.internal": "171",
+  "ito.techTeams.AI": "231",
+  "ito.techTeams.Angular": "234",
+  "kone.elevatorCall": "246",
+  "kone.mss": "188",
+};
+
+const PROJECT_TASKS = {
+  "kone.elevatorCall": {
+    2025: "3331",
+    Development: "3332",
+    Backend: "3333",
+    Frontend: "3334",
+    Infrastructure: "3335",
+    "IriusRisk assessment and remediation": "4440",
+    Meeting: "3336",
+    Projectmanagement: "3337",
+    "UI-UX": "3338",
+    Support: "3353",
+  },
+  "kone.mss": {
+    2025: "3832",
+    MSS: "3845",
+    "MSS - Backend": "3846",
+    "MSS - Frontend": "3847",
+    "MSS - Infrastructure": "3848",
+    "MSS - Meeting": "3849",
+    "MSS - Projectmanagement": "3850",
+    "MSS - Support": "3851",
+    "MSS - UI-UX": "3852",
+    Modap: "3837",
+    "Modap - Backend": "3838",
+    "Modap - Frontend": "3839",
+    "Modap - Infrastructure": "3840",
+    "Modap - Meeting": "3841",
+    "Modap - Projectmanagement": "3842",
+    "Modap - Support": "3843",
+    "Modap - UI-UX": "3844",
+    Support: "3853",
+    Incident: "3854",
+    Maintenance: "3855",
+    Meeting: "3856",
+  },
+  "ito.techTeams.Angular": {
+    2025: "3570",
+    "Angular Coordination": "4266",
+    "Angular Research": "4265",
+    "Development (Work Sessions)": "4263",
+    Onboarding: "3571",
+    Weekly: "3572",
+  },
+  "42ito.internal": {
+    "House Keeping": "4736",
+    Meeting: "4737",
+    "Other (Fallback for unknown tasks)": "4738",
+    Training: "4739",
+  },
+  "ito.techTeams.AI": {
+    2025: "3560",
+    "AI Team": "3561",
+    "AI General research": "3562",
+    "AI Meetings": "3563",
+    "AI Onboarding": "4531",
+    "AI Pitch deck and Workshop preparation": "3564",
+    "AI Prototyping": "4264",
+    "AI Research / Forschungsanträge": "3565",
+    "AI Strategy Development": "3566",
+    "Agentic AI Rollout": "4625",
+    "ITO Chatbot - Research / Development": "3567",
+    MLOps: "3569",
+  },
+};
+
+const LOCATIONS = {
+  auto: "NULL",
+  "home-office": "-HO-",
+  HO: "-HO-",
+  AT: "AT",
+  BE: "BE",
+  CZ: "CZ",
+  D: "D",
+  DK: "DK",
+  FI: "FI",
+  FR: "FR",
+  GB: "GB",
+  NL: "NL",
+  PT: "PT",
+  RU: "RU",
+  USA: "USA",
+};
+
+// ---- Browser + Cookie Management ----
+
+let _browser = null;
+let _headless = true;
+
+async function ensureBrowser(headless = true) {
+  if (_browser && _browser.connected) return _browser;
+
+  // Try connecting to existing debug instance
+  try {
+    _browser = await puppeteer.connect({
+      browserURL: `http://127.0.0.1:${CDP_PORT}`,
+      defaultViewport: null,
+    });
+    return _browser;
+  } catch {}
+
+  // Launch Chrome (headless by default, visible only for login)
+  fs.mkdirSync(PROFILE_DIR, { recursive: true });
+  _headless = headless;
+  _browser = await puppeteer.launch({
+    executablePath: CHROME_PATH,
+    headless: headless ? "new" : false,
+    userDataDir: PROFILE_DIR,
+    args: [
+      `--remote-debugging-port=${CDP_PORT}`,
+      "--no-first-run",
+      "--no-default-browser-check",
+      "--window-size=1200,800",
+    ],
+  });
+
+  // Reuse cookies if we have them
+  const cookies = loadCookies();
+  if (cookies.length > 0) {
+    const page = (await _browser.pages())[0] || (await _browser.newPage());
+    await page.setCookie(...cookies);
+  }
+
+  return _browser;
+}
+
+async function closeBrowser() {
+  if (_browser && _browser.connected) {
+    await _browser.close().catch(() => {});
+    _browser = null;
+  }
+}
+
+function loadCookies() {
+  try {
+    if (fs.existsSync(COOKIE_FILE)) {
+      return JSON.parse(fs.readFileSync(COOKIE_FILE, "utf8"));
+    }
+  } catch {}
+  return [];
+}
+
+function saveCookies(cookies) {
+  fs.writeFileSync(COOKIE_FILE, JSON.stringify(cookies, null, 2));
+}
+
+async function getZepPage() {
+  const browser = await ensureBrowser(true);
+  const pages = await browser.pages();
+
+  // Find or create a page
+  let page = pages[0] || (await browser.newPage());
+
+  // Always navigate to the main form page
+  const formUrl = `https://${ZEP_HOST}${ZEP_PATH}`;
+  const currentUrl = page.url();
+  if (
+    !currentUrl.includes("zep-online.de/zepitobjects/view/index.php") ||
+    currentUrl.includes("ajax") ||
+    currentUrl.includes("login")
+  ) {
+    await page.goto(formUrl, {
+      waitUntil: "networkidle2",
+      timeout: 60000,
+    });
+  }
+
+  // Check if we need login
+  const url = page.url();
+  if (
+    url.includes("login") ||
+    url.includes("saml") ||
+    url.includes("microsoftonline")
+  ) {
+    // Close headless browser and ask user to run zep_login
+    await closeBrowser();
+    throw new Error(
+      "SSO login required. Run the zep_login tool first to authenticate, then retry.",
+    );
+  }
+
+  // Wait for form and entries table to be available
+  await page.waitForSelector("#ProjektzeitFormMgr", { timeout: 10000 });
+  await page.waitForSelector("table tr", { timeout: 10000 }).catch(() => {});
+
+  // Save cookies for next time
+  const cookies = await page.cookies();
+  saveCookies(cookies);
+
+  return page;
+}
+
+// ---- Helper: delete entry by ID ----
+
+async function deleteEntryById(page, entryId) {
+  return await page.evaluate((entryId) => {
+    const rows = document.querySelectorAll("table tr");
+    for (const row of rows) {
+      const cells = row.querySelectorAll("td");
+      if (cells.length !== 10) continue;
+      const delLink = cells[0]?.querySelectorAll("a")[1];
+      if (!delLink) continue;
+      const onclick = delLink.getAttribute("onclick") || "";
+      if (onclick.includes("objectId=" + entryId)) {
+        const urlMatch = onclick.match(
+          /zepAjaxrequest_sendConfirmedDeleteGetRequest\s*\(\s*'[^']*'\s*,\s*'([^']*)'/,
+        );
+        if (urlMatch) {
+          zepAjaxrequest_sendGetRequest(urlMatch[1]);
+          return true;
+        }
+      }
+    }
+    return false;
+  }, entryId);
+}
+
+// ---- Helper: read full entry details from table row by ID ----
+
+async function readEntryDetails(page, entryId) {
+  return await page.evaluate((entryId) => {
+    const rows = document.querySelectorAll("table tr");
+    for (const row of rows) {
+      const cells = row.querySelectorAll("td");
+      if (cells.length !== 10) continue;
+      const editLink = cells[0]?.querySelector("a");
+      if (!editLink) continue;
+      const onclick = editLink.getAttribute("onclick") || "";
+      if (onclick.includes("objectId=" + entryId)) {
+        return {
+          from: cells[1]?.textContent?.trim(),
+          to: cells[2]?.textContent?.trim(),
+          project: cells[5]?.textContent?.trim(),
+          task: cells[6]?.textContent?.trim(),
+          activity: cells[7]?.textContent?.trim(),
+          remark: cells[9]?.textContent?.trim(),
+        };
+      }
+    }
+    return null;
+  }, entryId);
+}
+
+// ---- Form submission ----
+
+async function submitEntry(page, entry) {
+  // Always reload the page to get fresh data (avoids stale conflict checks)
+  await page.goto(`https://${ZEP_HOST}${ZEP_PATH}`, {
+    waitUntil: "networkidle2",
+    timeout: 30000,
+  });
+  await page.waitForSelector("form", { timeout: 10000 });
+
+  // Step 1: Check for time conflicts BEFORE touching the form (clean page state)
+  if (
+    !entry.onConflict ||
+    entry.onConflict === "ask" ||
+    entry.onConflict === "overwrite"
+  ) {
+    const [, mm, dd] = entry.date.split("-");
+    const targetDayLabel = `${dd}/${mm}`;
+
+    const conflicts = await page.evaluate(
+      (e) => {
+        const rows = document.querySelectorAll("table tr");
+        const found = [];
+        let inTargetDay = false;
+
+        for (const row of rows) {
+          const cells = row.querySelectorAll("td");
+          const rowspanCell = row.querySelector("td[rowspan]");
+          if (rowspanCell) {
+            inTargetDay = rowspanCell.textContent
+              .trim()
+              .includes(e.targetDayLabel);
+          }
+          if (row.textContent.includes("Total")) {
+            if (inTargetDay) break;
+            continue;
+          }
+          if (!inTargetDay) continue;
+
+          for (let i = 0; i < cells.length - 1; i++) {
+            const fromText = cells[i]?.textContent?.trim();
+            const toText = cells[i + 1]?.textContent?.trim();
+            if (
+              fromText &&
+              toText &&
+              /^\d{2}:\d{2}$/.test(fromText) &&
+              /^\d{2}:\d{2}$/.test(toText)
+            ) {
+              const [efh, efm] = e.from.split(":").map(Number);
+              const [eth, etm] = e.to.split(":").map(Number);
+              const [rfh, rfm] = fromText.split(":").map(Number);
+              const [rth, rtm] = toText.split(":").map(Number);
+              const eStart = efh * 60 + efm,
+                eEnd = eth * 60 + etm;
+              const rStart = rfh * 60 + rfm,
+                rEnd = rth * 60 + rtm;
+              if (eStart < rEnd && eEnd > rStart) {
+                let entryId = null;
+                const editLink = cells[0]?.querySelector("a");
+                if (editLink) {
+                  const onclick = editLink.getAttribute("onclick") || "";
+                  const idMatch = onclick.match(/objectId=(\d+)/);
+                  if (idMatch) entryId = idMatch[1];
+                }
+                let project = "",
+                  task = "";
+                for (let j = i + 2; j < cells.length; j++) {
+                  const txt = cells[j]?.textContent?.trim();
+                  if (
+                    txt &&
+                    (txt.includes("kone") ||
+                      txt.includes("ito") ||
+                      txt.includes("42ito"))
+                  )
+                    project = txt;
+                  if (
+                    txt &&
+                    (txt.includes("Frontend") ||
+                      txt.includes("Meeting") ||
+                      txt.includes("Weekly") ||
+                      txt.includes("Backend") ||
+                      txt.includes("MSS"))
+                  )
+                    task = txt;
+                }
+                found.push({
+                  from: fromText,
+                  to: toText,
+                  project,
+                  task,
+                  entryId,
+                });
+              }
+              break;
+            }
+          }
+        }
+        return found;
+      },
+      { ...entry, targetDayLabel },
+    );
+
+    if (conflicts.length > 0) {
+      if (entry.onConflict === "ask" || !entry.onConflict) {
+        const conflictInfo = conflicts
+          .map((c) => `${c.from}-${c.to} ${c.project} ${c.task}`)
+          .join(", ");
+        return {
+          success: false,
+          conflict: true,
+          error: `CONFLICT: ${entry.from}-${entry.to} overlaps with ${conflictInfo}. Ask user to choose: on_conflict="overwrite" (trim existing) or on_conflict="double_booking" (keep both).`,
+        };
+      }
+
+      if (entry.onConflict === "overwrite") {
+        // Smart overwrite: delete conflicting entries and re-create trimmed versions
+        const [efh, efm] = entry.from.split(":").map(Number);
+        const [eth, etm] = entry.to.split(":").map(Number);
+        const newStart = efh * 60 + efm;
+        const newEnd = eth * 60 + etm;
+        const fmtTime = (mins) =>
+          `${String(Math.floor(mins / 60)).padStart(2, "0")}:${String(mins % 60).padStart(2, "0")}`;
+
+        // Collect entries to re-create after deletion
+        const toRecreate = [];
+
+        for (const conflict of conflicts) {
+          if (!conflict.entryId) continue;
+          const [cfh, cfm] = conflict.from.split(":").map(Number);
+          const [cth, ctm] = conflict.to.split(":").map(Number);
+          const cStart = cfh * 60 + cfm;
+          const cEnd = cth * 60 + ctm;
+
+          // Read full details before deleting
+          const details = await readEntryDetails(page, conflict.entryId);
+
+          if (newStart <= cStart && newEnd >= cEnd) {
+            // New entry completely covers existing → just delete it
+            await deleteEntryById(page, conflict.entryId);
+            await new Promise((r) => setTimeout(r, 1500));
+          } else {
+            // Partial overlap → delete and re-create trimmed portion(s)
+            await deleteEntryById(page, conflict.entryId);
+            await new Promise((r) => setTimeout(r, 1500));
+
+            if (details) {
+              if (cStart < newStart) {
+                // Keep before-portion: conflict.from → newStart
+                toRecreate.push({
+                  ...details,
+                  from: conflict.from,
+                  to: fmtTime(newStart),
+                });
+              }
+              if (cEnd > newEnd) {
+                // Keep after-portion: newEnd → conflict.to
+                toRecreate.push({
+                  ...details,
+                  from: fmtTime(newEnd),
+                  to: conflict.to,
+                });
+              }
+            }
+          }
+        }
+
+        // Reload page, then re-create trimmed entries
+        for (const rec of toRecreate) {
+          await page.goto(`https://${ZEP_HOST}${ZEP_PATH}`, {
+            waitUntil: "networkidle2",
+            timeout: 30000,
+          });
+          await page.waitForSelector("form", { timeout: 10000 });
+
+          // Resolve project name to ID
+          let projectId = null;
+          for (const [name, id] of Object.entries(PROJECTS)) {
+            if (rec.project && rec.project.includes(name.split(".").pop())) {
+              projectId = id;
+              break;
+            }
+          }
+          // Resolve task name to ID
+          let taskId = null;
+          if (projectId) {
+            const projName = Object.entries(PROJECTS).find(
+              ([, id]) => id === projectId,
+            )?.[0];
+            if (projName) taskId = resolveTaskId(projName, rec.task);
+          }
+
+          if (!projectId || !taskId) continue; // skip if can't resolve
+
+          // Map activity text back to code
+          const actMap = { ar: "ar", fz: "fz", re: "re" };
+          const activity = actMap[rec.activity] || "ar";
+
+          // Map location text back to code
+          let location = "NULL";
+          for (const [, code] of Object.entries(LOCATIONS)) {
+            if (rec.location && rec.location.includes(code.replace(/-/g, ""))) {
+              location = code;
+              break;
+            }
+          }
+
+          const duration = calculateDuration(rec.from, rec.to);
+
+          // Set project
+          await page.evaluate((pid) => {
+            const form = document.querySelector("#ProjektzeitFormMgr");
+            form.querySelector('select[name="projektId"]').value = pid;
+            zepFormElement(
+              form.querySelector('select[name="projektId"]'),
+            ).refreshForm();
+          }, projectId);
+
+          await page.waitForFunction(
+            (tid) => {
+              const sel = document.querySelector(
+                "#ProjektzeitFormMgr select[name='vorgangId']",
+              );
+              return (
+                sel && Array.from(sel.options).some((opt) => opt.value === tid)
+              );
+            },
+            { timeout: 10000 },
+            taskId,
+          );
+
+          // Set fields
+          await page.evaluate(
+            (r) => {
+              const form = document.querySelector("#ProjektzeitFormMgr");
+              form.querySelector('input[name="datum"]').value = r.date;
+              form.querySelector('input[name="von"]').value = r.from;
+              form.querySelector('input[name="bis"]').value = r.to;
+              form.querySelector('input[name="dauer"]').value = r.duration;
+              form.querySelector('input[name="bemerkung"]').value =
+                r.remark || "";
+              const taskSel = form.querySelector('select[name="vorgangId"]');
+              if (taskSel) taskSel.value = r.taskId;
+              const actSel = form.querySelector('select[name="taetigkeit"]');
+              if (actSel) actSel.value = r.activity;
+              const ortSel = form.querySelector('select[name="ort"]');
+              if (ortSel) ortSel.value = r.location;
+              // Suppress double-booking popup
+              const dbField = form.querySelector(
+                'input[name="doppelbuchungTrotzdemFragenObUeberschreiben"]',
+              );
+              if (dbField) dbField.value = "0";
+              const ubtField = form.querySelector(
+                'input[name="ueberschreibenTrotzDoppelbuchung"]',
+              );
+              if (ubtField) ubtField.value = "1";
+            },
+            { ...rec, date: entry.date, duration, taskId, activity, location },
+          );
+
+          // Submit
+          await page.evaluate(() => {
+            const pm = $("form#ProjektzeitFormMgr").data("zepForm");
+            if (pm) pm.submitAjax();
+          });
+          await new Promise((r) => setTimeout(r, 3000));
+        }
+
+        // Final reload for the main entry submission
+        await page.goto(`https://${ZEP_HOST}${ZEP_PATH}`, {
+          waitUntil: "networkidle2",
+          timeout: 30000,
+        });
+        await page.waitForSelector("form", { timeout: 10000 });
+      }
+    }
+  }
+
+  // Step 2: Set project and trigger form refresh to load tasks
+  await page.evaluate((projectId) => {
+    const form = document.querySelector("#ProjektzeitFormMgr");
+    const projSel = form.querySelector('select[name="projektId"]');
+    projSel.value = projectId;
+    zepFormElement(projSel).refreshForm();
+  }, entry.projectId);
+
+  await page.waitForFunction(
+    (taskId) => {
+      const sel = document.querySelector(
+        "#ProjektzeitFormMgr select[name='vorgangId']",
+      );
+      if (!sel) return false;
+      return Array.from(sel.options).some((opt) => opt.value === taskId);
+    },
+    { timeout: 10000 },
+    entry.taskId,
+  );
+
+  // Step 3: Set all form fields
+  await page.evaluate((e) => {
+    const form = document.querySelector("#ProjektzeitFormMgr");
+
+    form.querySelector('input[name="datum"]').value = e.date;
+    form.querySelector('input[name="von"]').value = e.from;
+    form.querySelector('input[name="bis"]').value = e.to;
+    form.querySelector('input[name="dauer"]').value = e.duration;
+    form.querySelector('input[name="bemerkung"]').value = e.remark;
+
+    const taskSel = form.querySelector('select[name="vorgangId"]');
+    if (taskSel) taskSel.value = e.taskId;
+    const actSel = form.querySelector('select[name="taetigkeit"]');
+    if (actSel) actSel.value = e.activity;
+    const ortSel = form.querySelector('select[name="ort"]');
+    if (ortSel) ortSel.value = e.location;
+
+    const cb = form.querySelector('input[name="fakturierbar"]');
+    if (cb && cb.checked !== e.billable) cb.click();
+
+    // Suppress double-booking popup for non-"ask" modes
+    if (e.onConflict === "double_booking" || e.onConflict === "overwrite") {
+      const dbField = form.querySelector(
+        'input[name="doppelbuchungTrotzdemFragenObUeberschreiben"]',
+      );
+      if (dbField) dbField.value = "0";
+      const ubtField = form.querySelector(
+        'input[name="ueberschreibenTrotzDoppelbuchung"]',
+      );
+      if (ubtField) ubtField.value = "1";
+    }
+  }, entry);
+
+  // Step 3: Call ZEP's internal submitAjax directly on the private methods object.
+  // This bypasses isReady/global checks but uses ZEP's own AJAX with the CSRF token.
+  const submitResult = await page.evaluate(() => {
+    try {
+      const pm = $("form#ProjektzeitFormMgr").data("zepForm");
+      if (!pm) return { error: "zepForm private methods not found" };
+
+      // Call submitAjax directly — this sends the serialized form data
+      // via zepAjaxrequest_sendPostRequest which includes the x-requesttoken header
+      pm.submitAjax();
+
+      return { success: true };
+    } catch (e) {
+      return { error: e.message };
+    }
+  });
+
+  if (submitResult.error) {
+    return { success: false, error: submitResult.error };
+  }
+
+  // Wait for AJAX to complete
+  await new Promise((r) => setTimeout(r, 3000));
+
+  // Reload the page to get a fresh form for the next entry
+  await page.goto(`https://${ZEP_HOST}${ZEP_PATH}`, {
+    waitUntil: "networkidle2",
+    timeout: 30000,
+  });
+  await page.waitForSelector("#ProjektzeitFormMgr", { timeout: 10000 });
+
+  // Save fresh cookies
+  const cookies = await page.cookies();
+  saveCookies(cookies);
+
+  // Post-save verification: search all rows for matching from/to times
+  const verification = await page.evaluate((e) => {
+    const rows = document.querySelectorAll("table tr");
+    const allTimes = [];
+    for (const row of rows) {
+      const cells = row.querySelectorAll("td");
+      // Try to find From/To in the cells - check all cells for time patterns
+      for (let i = 0; i < cells.length - 1; i++) {
+        const text = cells[i]?.textContent?.trim();
+        const next = cells[i + 1]?.textContent?.trim();
+        if (
+          text &&
+          next &&
+          /^\d{2}:\d{2}$/.test(text) &&
+          /^\d{2}:\d{2}$/.test(next)
+        ) {
+          allTimes.push({ from: text, to: next, cellCount: cells.length });
+          if (text === e.from && next === e.to)
+            return { found: true, allTimes };
+          break; // only check first time pair per row
+        }
+      }
+    }
+    return { found: false, allTimes };
+  }, entry);
+
+  if (!verification.found) {
+    return {
+      success: true,
+      verified: false,
+      warning: "Entry submitted but not found on current week view",
+      debug: { existingTimes: verification.allTimes },
+    };
+  }
+
+  return { success: true, error: null, verified: true };
+}
+
+function calculateDuration(from, to) {
+  const [fh, fm] = from.split(":").map(Number);
+  const [th, tm] = to.split(":").map(Number);
+  const totalMinutes = th * 60 + tm - (fh * 60 + fm);
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}`;
+}
+
+// ---- Login helper ----
+
+async function doLogin() {
+  // Close any existing headless browser
+  await closeBrowser();
+
+  // Launch visible Chrome for SSO login
+  const browser = await ensureBrowser(false);
+  const pages = await browser.pages();
+  const page = pages[0] || (await browser.newPage());
+
+  await page.goto(`https://${ZEP_HOST}${ZEP_PATH}`, {
+    waitUntil: "networkidle2",
+    timeout: 60000,
+  });
+
+  // Wait for user to complete SSO login (poll for up to 2 minutes)
+  for (let i = 0; i < 24; i++) {
+    await new Promise((r) => setTimeout(r, 5000));
+    const url = page.url();
+    if (
+      url.includes("zep-online.de/zepitobjects/view/index.php") &&
+      !url.includes("login") &&
+      !url.includes("saml") &&
+      !url.includes("microsoftonline")
+    ) {
+      // Login successful - save cookies
+      const cookies = await page.cookies();
+      saveCookies(cookies);
+      // Close visible browser, next call will use headless
+      await closeBrowser();
+      return true;
+    }
+  }
+
+  await closeBrowser();
+  return false;
+}
+
+// ---- Task name resolver ----
+
+function resolveTaskId(project, taskInput) {
+  const tasks = PROJECT_TASKS[project];
+
+  // If numeric, check if it's a known task ID first, then try as a name
+  if (/^\d+$/.test(taskInput)) {
+    // Check if it's a valid task ID for this project
+    if (tasks) {
+      const ids = Object.values(tasks);
+      if (ids.includes(taskInput)) return taskInput;
+      // Maybe it's a task name that happens to be numeric (like "2025")
+      if (tasks[taskInput]) return tasks[taskInput];
+    }
+    return taskInput; // assume it's a valid ID even if not in our map
+  }
+
+  if (!tasks) return null;
+
+  const lower = taskInput.toLowerCase();
+  // Try exact match first
+  for (const [name, id] of Object.entries(tasks)) {
+    if (name.toLowerCase() === lower) return id;
+  }
+  // Then partial match
+  for (const [name, id] of Object.entries(tasks)) {
+    if (
+      name.toLowerCase().includes(lower) ||
+      lower.includes(name.toLowerCase())
+    )
+      return id;
+  }
+  return null;
+}
+
+// ---- MCP Server ----
+
+const instructions = `# ZEP Time Tracking MCP
+
+This MCP provides tools for logging and managing time entries in ZEP (zep-online.de).
+
+## When to use these tools
+
+Use these tools whenever the user wants to:
+- Log time (e.g. "log 9-12 on kone frontend", "book my hours", "log today")
+- Read time entries (e.g. "show my hours this week", "what did I log today")
+- Edit or delete entries (e.g. "change my 9-12 to 9-11", "delete that entry")
+- List projects or tasks (e.g. "show zep projects", "what tasks does kone have")
+
+## IMPORTANT
+
+- When the user says to log time, use zep_log_time or zep_log_day immediately. Do NOT ask for confirmation unless there's a conflict.
+- Default activity is "ar" (working), default location is "auto".
+- When a conflict is returned, present the user with options: Overwrite, Double booking, or Cancel.
+- If a tool reports "SSO login required", use zep_login first, then retry.
+- Use zep_list_projects to show available projects and tasks.
+`;
+
+const server = new McpServer(
+  { name: "zep", version: "3.0.0" },
+  { instructions },
+);
+
+server.tool(
+  "zep_login",
+  "Open a visible Chrome window for SSO login to ZEP. Run this when other tools report SSO login required.",
+  {},
+  async () => {
+    try {
+      const success = await doLogin();
+      if (success) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Login successful. Cookies saved. You can now use other ZEP tools.",
+            },
+          ],
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: "Login timed out after 2 minutes. Please try again.",
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: `Login error: ${error.message}` }],
+      };
+    }
+  },
+);
+
+server.tool(
+  "zep_log_time",
+  "Log a time entry in ZEP. Task can be a name (e.g. 'Weekly', 'MSS - Frontend') or numeric ID. Use zep_get_tasks to list available tasks for a project. IMPORTANT: When a conflict is returned, present the user with an interactive selection prompt (not text) with options: Overwrite, Double booking, Cancel.",
+  {
+    date: z.string().describe("Date in YYYY-MM-DD format"),
+    from: z.string().describe("Start time in HH:MM format (e.g. 09:00)"),
+    to: z.string().describe("End time in HH:MM format (e.g. 17:00)"),
+    project: z.enum(Object.keys(PROJECTS)).describe("Project name"),
+    task: z
+      .string()
+      .describe("Task name (e.g. 'Weekly', 'MSS - Frontend') or numeric ID"),
+    activity: z
+      .enum(["ar", "fz", "re"])
+      .default("ar")
+      .describe("Activity type: ar(working), fz(freetime), re(traveling)"),
+    location: z
+      .enum(Object.keys(LOCATIONS))
+      .default("auto")
+      .describe("Work location (auto=let ZEP decide, HO=home-office)"),
+    remark: z.string().default("").describe("Optional remark/comment"),
+    billable: z.boolean().default(true).describe("Is the entry billable?"),
+    on_conflict: z
+      .enum(["ask", "double_booking", "overwrite"])
+      .default("ask")
+      .describe(
+        "What to do if time overlaps: ask=report conflict, double_booking=save alongside, overwrite=replace existing",
+      ),
+  },
+  async (params) => {
+    try {
+      // Resolve task name to ID
+      const taskId = resolveTaskId(params.project, params.task);
+      if (!taskId) {
+        const tasks = PROJECT_TASKS[params.project];
+        const available = tasks
+          ? Object.entries(tasks)
+              .map(([n, id]) => `${id}: ${n}`)
+              .join(", ")
+          : "none";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Unknown task "${params.task}" for ${params.project}. Available: ${available}`,
+            },
+          ],
+        };
+      }
+
+      const page = await getZepPage();
+      const duration = calculateDuration(params.from, params.to);
+
+      const result = await submitEntry(page, {
+        date: params.date,
+        from: params.from,
+        to: params.to,
+        duration,
+        projectId: PROJECTS[params.project],
+        taskId,
+        activity: params.activity,
+        location: LOCATIONS[params.location] || "-HO-",
+        remark: params.remark,
+        billable: params.billable,
+        onConflict: params.on_conflict,
+      });
+
+      if (result.conflict) {
+        return { content: [{ type: "text", text: result.error }] };
+      }
+      if (!result.success) {
+        return { content: [{ type: "text", text: `FAILED: ${result.error}` }] };
+      }
+
+      let status = `Logged: ${params.date} ${params.from}-${params.to} (${duration}) | ${params.project} | task ${params.task} | ${params.activity} | ${params.remark || "(no remark)"}`;
+      if (result.verified === false) {
+        status += `\nNOT VERIFIED: ${result.warning}`;
+      } else if (result.verified) {
+        status += `\nVERIFIED: Entry confirmed on page`;
+      }
+      return { content: [{ type: "text", text: status }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
+  },
+);
+
+server.tool(
+  "zep_log_day",
+  "Log multiple time entries for a full day in ZEP",
+  {
+    date: z.string().describe("Date in YYYY-MM-DD format"),
+    entries: z
+      .array(
+        z.object({
+          from: z.string().describe("Start time HH:MM"),
+          to: z.string().describe("End time HH:MM"),
+          project: z.enum(Object.keys(PROJECTS)),
+          task: z
+            .string()
+            .describe(
+              "Task name (e.g. 'Weekly', 'MSS - Frontend') or numeric ID",
+            ),
+          activity: z.enum(["ar", "fz", "re"]).default("ar"),
+          location: z.enum(Object.keys(LOCATIONS)).default("auto"),
+          remark: z.string().default(""),
+          billable: z.boolean().default(true),
+        }),
+      )
+      .describe("Array of time entries for the day"),
+    on_conflict: z
+      .enum(["ask", "double_booking", "overwrite"])
+      .default("overwrite")
+      .describe(
+        "What to do if time overlaps with existing entries (default: overwrite/trim existing)",
+      ),
+  },
+  async (params) => {
+    try {
+      const page = await getZepPage();
+      const results = [];
+
+      for (let idx = 0; idx < params.entries.length; idx++) {
+        const entry = params.entries[idx];
+        const taskId = resolveTaskId(entry.project, entry.task);
+        if (!taskId) {
+          results.push({
+            time: `${entry.from}-${entry.to}`,
+            project: entry.project,
+            success: false,
+            error: `Unknown task "${entry.task}"`,
+          });
+          continue;
+        }
+        const duration = calculateDuration(entry.from, entry.to);
+        const result = await submitEntry(page, {
+          date: params.date,
+          from: entry.from,
+          to: entry.to,
+          duration,
+          projectId: PROJECTS[entry.project],
+          taskId,
+          activity: entry.activity || "ar",
+          location: LOCATIONS[entry.location] || "-HO-",
+          remark: entry.remark || "",
+          billable: entry.billable !== false,
+          onConflict: params.on_conflict,
+        });
+
+        // If any entry has a conflict in "ask" mode, stop the entire batch
+        if (result.conflict) {
+          results.push({
+            time: `${entry.from}-${entry.to}`,
+            project: entry.project,
+            success: false,
+            error: result.error,
+          });
+          // Add remaining entries as skipped
+          for (let j = idx + 1; j < params.entries.length; j++) {
+            const skip = params.entries[j];
+            results.push({
+              time: `${skip.from}-${skip.to}`,
+              project: skip.project,
+              success: false,
+              error: "Skipped due to earlier conflict",
+            });
+          }
+          break;
+        }
+
+        results.push({
+          time: `${entry.from}-${entry.to}`,
+          project: entry.project,
+          success: result.success,
+          verified: result.verified,
+          warning: result.warning,
+          error: result.error,
+        });
+      }
+
+      const summary = results
+        .map((r) => {
+          if (!r.success) return `${r.time} ${r.project}: FAILED - ${r.error}`;
+          if (r.verified === false)
+            return `${r.time} ${r.project}: OK (UNVERIFIED - ${r.warning})`;
+          return `${r.time} ${r.project}: OK (verified)`;
+        })
+        .join("\n");
+
+      return {
+        content: [{ type: "text", text: `Day ${params.date}:\n${summary}` }],
+      };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
+  },
+);
+
+server.tool(
+  "zep_read_entries",
+  "Read time entries from ZEP for a given week",
+  {
+    week_start: z
+      .string()
+      .optional()
+      .describe(
+        "Week start date in YYYY-MM-DD format (Monday). Defaults to current week.",
+      ),
+  },
+  async (params) => {
+    try {
+      const page = await getZepPage();
+
+      if (params.week_start) {
+        // Navigate to the target week by finding the matching dropdown option
+        const navResult = await page.evaluate((targetDate) => {
+          const sel = document.querySelector("#pz_kwnav");
+          if (!sel) return { error: "no_dropdown" };
+
+          const options = Array.from(sel.options).map(o => ({ value: o.value, text: o.textContent.trim() }));
+
+          // Parse target date
+          const [y, m, d] = targetDate.split("-");
+          const altFormats = [
+            targetDate,                    // 2026-02-02
+            `${d}.${m}.${y}`,             // 02.02.2026
+            `${d}/${m}/${y}`,             // 02/02/2026
+          ];
+
+          // Compute ISO week number for KW matching
+          const date = new Date(targetDate + "T12:00:00");
+          const dayOfWeek = date.getDay() || 7;
+          const jan4 = new Date(date.getFullYear(), 0, 4);
+          const jan4DayOfWeek = jan4.getDay() || 7;
+          const weekNum = Math.ceil(((date - jan4) / 86400000 + jan4DayOfWeek + 3) / 7);
+          const kwStr = String(weekNum).padStart(2, "0");
+          const kwYear = date.getFullYear();
+
+          // The dropdown values are dates in YYYY-MM-DD format (e.g. "2026-02-02")
+          // and text is like "5/2026  (02.02-08.02)"
+          // We need to find the option whose date range contains our target date
+          const targetMs = date.getTime();
+          let matchValue = null;
+
+          for (const opt of options) {
+            const v = opt.value;
+            // Strategy 1: exact value match
+            if (v === targetDate) { matchValue = v; break; }
+            // Strategy 2: the option value is a date — check if our target falls within that week
+            if (/^\d{4}-\d{2}-\d{2}$/.test(v)) {
+              const optDate = new Date(v + "T12:00:00");
+              const weekStart = optDate.getTime();
+              const weekEnd = weekStart + 6 * 86400000; // 6 days later (Mon-Sun)
+              if (targetMs >= weekStart && targetMs <= weekEnd) {
+                matchValue = v;
+                break;
+              }
+            }
+          }
+
+          if (matchValue) {
+            sel.value = matchValue;
+            sel.dispatchEvent(new Event("change", { bubbles: true }));
+            return { success: true, matchValue };
+          }
+
+          return { error: "no_match", options: options.slice(0, 15), weekNum, kwStr, kwYear };
+        }, params.week_start);
+
+        if (navResult.error === "no_dropdown" || navResult.error === "no_match") {
+          return {
+            content: [{
+              type: "text",
+              text: `Could not find week for ${params.week_start} (KW${navResult.kwStr}/${navResult.kwYear}) in dropdown. Available options: ${JSON.stringify(navResult.options)}`
+            }]
+          };
+        }
+
+        if (navResult.success) {
+          // Wait for page to reload after week change
+          await page.waitForNavigation({ waitUntil: "networkidle2", timeout: 10000 }).catch(() => {});
+          await page.waitForSelector("table tr", { timeout: 5000 }).catch(() => {});
+          // Extra wait for dynamic content
+          await new Promise(r => setTimeout(r, 1000));
+
+        }
+      }
+
+      const entries = await page.evaluate(() => {
+        const allRows = document.querySelectorAll("table tr");
+        const results = [];
+        let currentDay = "";
+
+        for (const row of allRows) {
+          // Day header rows have class "day" or "tag_N" and 2 cells
+          if (
+            row.classList.contains("day") ||
+            (row.className.match(/tag_\d/) &&
+              row.querySelectorAll("td").length === 2)
+          ) {
+            const text = row.textContent.trim();
+            const match = text.match(/(\w{2})(\d{2}\/\d{2})/);
+            if (match) currentDay = match[1] + " " + match[2];
+            continue;
+          }
+
+          // Entry rows have 10 or 11 cells (11 when Location column is present)
+          const cells = row.querySelectorAll("td");
+          if (cells.length >= 10 && cells.length <= 11) {
+            // Extract objectId from edit link's onclick
+            const editLink = cells[0]?.querySelector("a");
+            const onclick = editLink?.getAttribute("onclick") || "";
+            const idMatch = onclick.match(/objectId=(\d+)/);
+            if (!idMatch) continue; // Skip rows without edit links (e.g. total rows)
+            const hasLocation = cells.length === 11;
+            results.push({
+              id: idMatch[1],
+              day: currentDay,
+              from: cells[1]?.textContent?.trim() || "",
+              to: cells[2]?.textContent?.trim() || "",
+              duration: cells[3]?.textContent?.trim() || "",
+              project: cells[5]?.textContent?.trim() || "",
+              task: cells[6]?.textContent?.trim() || "",
+              activity: cells[7]?.textContent?.trim() || "",
+              remark: cells[hasLocation ? 10 : 9]?.textContent?.trim() || "",
+            });
+          }
+        }
+        return results;
+      });
+
+      if (entries.length === 0) {
+        return {
+          content: [
+            { type: "text", text: "No time entries found for this week." },
+          ],
+        };
+      }
+
+      return {
+        content: [{ type: "text", text: JSON.stringify(entries, null, 2) }],
+      };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
+  },
+);
+
+server.tool(
+  "zep_list_projects",
+  "List available ZEP projects and their task IDs",
+  {},
+  async () => {
+    const output = Object.entries(PROJECT_TASKS)
+      .map(([proj, tasks]) => {
+        const taskList = Object.entries(tasks)
+          .map(([name, id]) => `  ${id}: ${name}`)
+          .join("\n");
+        return `${proj} (ID: ${PROJECTS[proj]}):\n${taskList}`;
+      })
+      .join("\n\n");
+
+    return { content: [{ type: "text", text: output }] };
+  },
+);
+
+server.tool(
+  "zep_get_tasks",
+  "Fetch available tasks for a specific project from ZEP (requires loading the page)",
+  {
+    project: z.enum(Object.keys(PROJECTS)).describe("Project name"),
+  },
+  async (params) => {
+    const known = PROJECT_TASKS[params.project];
+    if (known) {
+      const taskList = Object.entries(known)
+        .map(([name, id]) => `${id}: ${name}`)
+        .join("\n");
+      return {
+        content: [
+          { type: "text", text: `Tasks for ${params.project}:\n${taskList}` },
+        ],
+      };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: `No cached tasks for ${params.project}. Check zep_list_projects.`,
+        },
+      ],
+    };
+  },
+);
+
+server.tool(
+  "zep_delete_entry",
+  "Delete a time entry from ZEP by its ID (use zep_read_entries to get IDs). Entries can always be re-created, so proceed without asking for confirmation when the user's intent is clear.",
+  {
+    entry_id: z
+      .string()
+      .describe("The entry objectId to delete (from zep_read_entries)"),
+  },
+  async (params) => {
+    try {
+      const page = await getZepPage();
+
+      // Find the delete link for this entry by objectId
+      const found = await page.evaluate((entryId) => {
+        const rows = document.querySelectorAll("table tr");
+        for (const row of rows) {
+          const cells = row.querySelectorAll("td");
+          if (cells.length !== 10) continue;
+          const delLink = cells[0]?.querySelectorAll("a")[1];
+          if (!delLink) continue;
+          const onclick = delLink.getAttribute("onclick") || "";
+          if (onclick.includes("objectId=" + entryId)) {
+            return { rowIndex: Array.from(rows).indexOf(row) };
+          }
+        }
+        return null;
+      }, params.entry_id);
+
+      if (!found) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Entry ${params.entry_id} not found on current week.`,
+            },
+          ],
+        };
+      }
+
+      const deleted = await deleteEntryById(page, params.entry_id);
+
+      if (!deleted) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Could not extract delete URL for entry ${params.entry_id}.`,
+            },
+          ],
+        };
+      }
+
+      // Wait for AJAX delete to complete
+      await new Promise((r) => setTimeout(r, 3000));
+
+      // Reload page to see updated entries
+      await page.goto(`https://${ZEP_HOST}${ZEP_PATH}`, {
+        waitUntil: "networkidle2",
+        timeout: 30000,
+      });
+      await page.waitForSelector("#ProjektzeitFormMgr", { timeout: 10000 });
+
+      return {
+        content: [{ type: "text", text: `Deleted entry ${params.entry_id}.` }],
+      };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
+  },
+);
+
+server.tool(
+  "zep_edit_entry",
+  "Edit an existing time entry in ZEP by deleting and re-creating it with modified fields",
+  {
+    entry_id: z
+      .string()
+      .describe("The entry objectId to edit (from zep_read_entries)"),
+    date: z
+      .string()
+      .optional()
+      .describe("New date in YYYY-MM-DD format (leave empty to keep current)"),
+    from: z
+      .string()
+      .optional()
+      .describe("New start time HH:MM (leave empty to keep current)"),
+    to: z
+      .string()
+      .optional()
+      .describe("New end time HH:MM (leave empty to keep current)"),
+    project: z
+      .enum(Object.keys(PROJECTS))
+      .optional()
+      .describe("New project (leave empty to keep current)"),
+    task: z
+      .string()
+      .optional()
+      .describe("New task name or ID (leave empty to keep current)"),
+    activity: z
+      .enum(["ar", "fz", "re"])
+      .optional()
+      .describe("New activity type"),
+    location: z
+      .enum(Object.keys(LOCATIONS))
+      .optional()
+      .describe("New work location"),
+    remark: z.string().optional().describe("New remark"),
+    billable: z.boolean().optional().describe("New billable status"),
+  },
+  async (params) => {
+    try {
+      const page = await getZepPage();
+
+      // Step 1: Read current entry details from the table
+      const current = await readEntryDetails(page, params.entry_id);
+      if (!current) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Entry ${params.entry_id} not found on current week.`,
+            },
+          ],
+        };
+      }
+
+      // Also read the date from the day header for this entry
+      const currentDate = await page.evaluate((entryId) => {
+        const rows = document.querySelectorAll("table tr");
+        let currentDay = "";
+        for (const row of rows) {
+          const rowspanCell = row.querySelector("td[rowspan]");
+          if (rowspanCell) {
+            const match = rowspanCell.textContent.match(/(\d{2})\/(\d{2})/);
+            if (match) currentDay = match[0]; // DD/MM
+          }
+          const cells = row.querySelectorAll("td");
+          if (cells.length !== 10) continue;
+          const editLink = cells[0]?.querySelector("a");
+          if (!editLink) continue;
+          const onclick = editLink.getAttribute("onclick") || "";
+          if (onclick.includes("objectId=" + entryId)) {
+            return currentDay; // DD/MM
+          }
+        }
+        return null;
+      }, params.entry_id);
+
+      // Step 2: Delete the existing entry
+      const deleted = await deleteEntryById(page, params.entry_id);
+      if (!deleted) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Could not delete entry ${params.entry_id}.`,
+            },
+          ],
+        };
+      }
+      await new Promise((r) => setTimeout(r, 2000));
+
+      // Step 3: Resolve project and task for the re-creation
+      // Use new values if provided, otherwise resolve from current entry text
+      let projectName = params.project;
+      let projectId = params.project ? PROJECTS[params.project] : null;
+      if (!projectId) {
+        // Resolve from current entry's project text
+        for (const [name, id] of Object.entries(PROJECTS)) {
+          const shortName = name.split(".").pop();
+          if (current.project && current.project.includes(shortName)) {
+            projectName = name;
+            projectId = id;
+            break;
+          }
+        }
+      }
+      if (!projectId) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Could not resolve project from "${current.project}". Entry was deleted but not re-created.`,
+            },
+          ],
+        };
+      }
+
+      let taskId = params.task ? resolveTaskId(projectName, params.task) : null;
+      if (!taskId) {
+        taskId = resolveTaskId(projectName, current.task);
+      }
+      if (!taskId) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Could not resolve task from "${current.task}". Entry was deleted but not re-created.`,
+            },
+          ],
+        };
+      }
+
+      // Determine final values (new overrides current)
+      const finalFrom = params.from || current.from;
+      const finalTo = params.to || current.to;
+      const finalActivity = params.activity || current.activity || "ar";
+      const finalRemark =
+        params.remark !== undefined ? params.remark : current.remark || "";
+
+      // Resolve location
+      let finalLocation = "NULL";
+      if (params.location) {
+        finalLocation = LOCATIONS[params.location] || "-HO-";
+      } else if (current.location) {
+        // Map location text back to code
+        for (const [, code] of Object.entries(LOCATIONS)) {
+          if (current.location.includes(code.replace(/-/g, ""))) {
+            finalLocation = code;
+            break;
+          }
+        }
+      }
+
+      // Resolve date: use params.date, or reconstruct from DD/MM + current year
+      let finalDate = params.date;
+      if (!finalDate && currentDate) {
+        const [dd, mm] = currentDate.split("/");
+        const year = new Date().getFullYear();
+        finalDate = `${year}-${mm}-${dd}`;
+      }
+      if (!finalDate) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Could not determine date. Entry was deleted but not re-created.`,
+            },
+          ],
+        };
+      }
+
+      const duration = calculateDuration(finalFrom, finalTo);
+
+      // Step 4: Re-create the entry with modifications
+      await page.goto(`https://${ZEP_HOST}${ZEP_PATH}`, {
+        waitUntil: "networkidle2",
+        timeout: 30000,
+      });
+      await page.waitForSelector("form", { timeout: 10000 });
+
+      // Set project
+      await page.evaluate((pid) => {
+        const form = document.querySelector("#ProjektzeitFormMgr");
+        form.querySelector('select[name="projektId"]').value = pid;
+        zepFormElement(
+          form.querySelector('select[name="projektId"]'),
+        ).refreshForm();
+      }, projectId);
+
+      await page.waitForFunction(
+        (tid) => {
+          const sel = document.querySelector(
+            "#ProjektzeitFormMgr select[name='vorgangId']",
+          );
+          return (
+            sel && Array.from(sel.options).some((opt) => opt.value === tid)
+          );
+        },
+        { timeout: 10000 },
+        taskId,
+      );
+
+      // Set all fields
+      await page.evaluate(
+        (e) => {
+          const form = document.querySelector("#ProjektzeitFormMgr");
+          form.querySelector('input[name="datum"]').value = e.date;
+          form.querySelector('input[name="von"]').value = e.from;
+          form.querySelector('input[name="bis"]').value = e.to;
+          form.querySelector('input[name="dauer"]').value = e.duration;
+          form.querySelector('input[name="bemerkung"]').value = e.remark;
+          const taskSel = form.querySelector('select[name="vorgangId"]');
+          if (taskSel) taskSel.value = e.taskId;
+          const actSel = form.querySelector('select[name="taetigkeit"]');
+          if (actSel) actSel.value = e.activity;
+          const ortSel = form.querySelector('select[name="ort"]');
+          if (ortSel) ortSel.value = e.location;
+          // Suppress double-booking popup
+          const dbField = form.querySelector(
+            'input[name="doppelbuchungTrotzdemFragenObUeberschreiben"]',
+          );
+          if (dbField) dbField.value = "0";
+          const ubtField = form.querySelector(
+            'input[name="ueberschreibenTrotzDoppelbuchung"]',
+          );
+          if (ubtField) ubtField.value = "1";
+        },
+        {
+          date: finalDate,
+          from: finalFrom,
+          to: finalTo,
+          duration,
+          remark: finalRemark,
+          taskId,
+          activity: finalActivity,
+          location: finalLocation,
+        },
+      );
+
+      // Submit
+      const submitResult = await page.evaluate(() => {
+        try {
+          const pm = $("form#ProjektzeitFormMgr").data("zepForm");
+          if (!pm) return { error: "zepForm not found" };
+          pm.submitAjax();
+          return { success: true };
+        } catch (e) {
+          return { error: e.message };
+        }
+      });
+
+      if (submitResult.error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Edit failed during re-creation: ${submitResult.error}. Original entry was deleted.`,
+            },
+          ],
+        };
+      }
+
+      await new Promise((r) => setTimeout(r, 3000));
+
+      const changes = [];
+      if (params.from || params.to)
+        changes.push(`time: ${finalFrom}-${finalTo}`);
+      if (params.project) changes.push(`project: ${params.project}`);
+      if (params.task) changes.push(`task: ${params.task}`);
+      if (params.location) changes.push(`location: ${params.location}`);
+      if (params.activity) changes.push(`activity: ${params.activity}`);
+      if (params.remark !== undefined) changes.push(`remark: ${params.remark}`);
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Edited entry ${params.entry_id}: ${changes.join(", ") || "updated"}`,
+          },
+        ],
+      };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
+  },
+);
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch(console.error);