@leadertechie/personal-site-kit 0.0.0 → 0.1.0-alpha.10

package/dist/chunks/website-api-CuyeBej-.js

@@ -0,0 +1,920 @@
+import { R2ContentLoader } from "@leadertechie/r2tohtml";
+function createJSONResponse(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function createErrorResponse(message, status = 500) {
+  return createJSONResponse({ error: message }, status);
+}
+let loader$1 = null;
+function getLoader$1(env) {
+  if (!env?.CONTENT_BUCKET) {
+    return null;
+  }
+  if (!loader$1) {
+    loader$1 = new R2ContentLoader(
+      {
+        bucket: env.CONTENT_BUCKET,
+        cacheTTL: 5 * 60 * 1e3
+      },
+      {
+        md2html: {
+          imagePathPrefix: "images/",
+          styleOptions: {
+            classPrefix: "md-",
+            addHeadingIds: true
+          }
+        }
+      }
+    );
+  }
+  return loader$1;
+}
+function clearContentCache$1() {
+  loader$1?.clearCache();
+}
+async function handleAboutMe(env) {
+  try {
+    console.log("handleAboutMe: env?.CONTENT_BUCKET =", !!env?.CONTENT_BUCKET);
+    if (!env?.CONTENT_BUCKET) {
+      return new Response(JSON.stringify({ error: "Content bucket not configured", env: !!env }), {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    const r2 = getLoader$1(env);
+    if (!r2) {
+      return new Response(JSON.stringify({ error: "Content bucket not configured" }), {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    console.log("handleAboutMe: r2 created, fetching data");
+    const [profileObj, rendered] = await Promise.all([
+      r2.getObject("profile.json"),
+      r2.getRendered("about-me.md")
+    ]);
+    if (!rendered) {
+      return new Response(JSON.stringify({ error: "About-me content not found. Please run seed." }), {
+        status: 404,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    let profile = {
+      name: "Your Name",
+      title: "Professional",
+      experience: "Experienced",
+      profileImageUrl: ""
+    };
+    if (profileObj) {
+      profile = await profileObj.json();
+    }
+    console.log("handleAboutMe: profile loaded:", profile.name);
+    const responseData = {
+      profile,
+      contentNodes: [],
+      processedMarkdown: rendered.content
+    };
+    return new Response(JSON.stringify(responseData), {
+      headers: { "Content-Type": "application/json" }
+    });
+  } catch (error) {
+    console.error("Error serving aboutme content:", error);
+    return new Response(JSON.stringify({ error: "Content not available", message: String(error) }), {
+      status: 500,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+}
+let loader = null;
+function getLoader(env) {
+  if (!loader && env?.CONTENT_BUCKET) {
+    loader = new R2ContentLoader(
+      {
+        bucket: env.CONTENT_BUCKET,
+        cacheTTL: 5 * 60 * 1e3
+      },
+      {
+        md2html: {
+          imagePathPrefix: "images/",
+          styleOptions: {
+            classPrefix: "md-",
+            addHeadingIds: true
+          }
+        }
+      }
+    );
+  }
+  return loader;
+}
+function clearContentCache() {
+  loader?.clearCache();
+}
+async function handleHome(env) {
+  try {
+    if (!env?.CONTENT_BUCKET) {
+      return new Response(JSON.stringify({ error: "Content bucket not configured" }), {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    const r2 = getLoader(env);
+    let astResult = await r2.getWithAST("pages/home.md");
+    let renderedResult = await r2.getRendered("pages/home.md");
+    if (!astResult || !renderedResult) {
+      return new Response(JSON.stringify({
+        contentNodes: [],
+        processedMarkdown: "",
+        content: ""
+      }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    const responseData = {
+      contentNodes: astResult.contentNodes,
+      processedMarkdown: "",
+      content: renderedResult.content
+    };
+    return new Response(JSON.stringify(responseData), {
+      headers: { "Content-Type": "application/json" }
+    });
+  } catch (error) {
+    console.error("Error serving home content:", error);
+    return new Response(JSON.stringify({ error: "Content not available" }), {
+      status: 500,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+}
+async function handleInfo() {
+  return createJSONResponse({
+    name: "TechieLeader",
+    version: "1.0.0",
+    description: "TechieLeader API",
+    endpoints: [
+      { path: "/info", method: "GET", description: "Get API information" }
+    ]
+  });
+}
+const AUTH_KV = "auth_store";
+const RATE_LIMIT_KV = "rate_limit";
+const MAX_ATTEMPTS = 5;
+const BASE_DELAY_MS = 1e3;
+const MAX_DELAY_MS = 6e4;
+async function hashPassword(password, salt) {
+  const encoder = new TextEncoder();
+  const keyMaterial = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(password),
+    "PBKDF2",
+    false,
+    ["deriveBits"]
+  );
+  const saltBuffer = encoder.encode(salt);
+  const derivedBits = await crypto.subtle.deriveBits(
+    {
+      name: "PBKDF2",
+      salt: saltBuffer,
+      iterations: 1e5,
+      hash: "SHA-256"
+    },
+    keyMaterial,
+    256
+  );
+  return btoa(String.fromCharCode(...new Uint8Array(derivedBits)));
+}
+async function generateSalt() {
+  const saltBytes = crypto.getRandomValues(new Uint8Array(16));
+  return btoa(String.fromCharCode(...saltBytes));
+}
+async function checkRateLimit(env, ip) {
+  const kvKey = `rate:${ip}`;
+  const entry = await env.KV.get(kvKey, "json");
+  if (!entry) {
+    return { allowed: true, delayMs: 0 };
+  }
+  const now = Date.now();
+  const windowMs = 15 * 60 * 1e3;
+  if (now - entry.firstAttempt > windowMs) {
+    return { allowed: true, delayMs: 0 };
+  }
+  if (entry.attempts >= MAX_ATTEMPTS) {
+    const delayMs = Math.min(BASE_DELAY_MS * Math.pow(2, entry.attempts - MAX_ATTEMPTS), MAX_DELAY_MS);
+    const timeSinceLast = now - entry.lastAttempt;
+    if (timeSinceLast < delayMs) {
+      return { allowed: false, delayMs: delayMs - timeSinceLast };
+    }
+  }
+  return { allowed: true, delayMs: 0 };
+}
+async function recordFailedAttempt(env, ip) {
+  const kvKey = `rate:${ip}`;
+  const entry = await env.KV.get(kvKey, "json");
+  const now = Date.now();
+  const windowMs = 15 * 60 * 1e3;
+  if (!entry || now - entry.firstAttempt > windowMs) {
+    await env.KV.put(kvKey, JSON.stringify({
+      attempts: 1,
+      firstAttempt: now,
+      lastAttempt: now
+    }), { expirationTtl: Math.ceil(windowMs / 1e3) + 60 });
+  } else {
+    entry.attempts++;
+    entry.lastAttempt = now;
+    await env.KV.put(kvKey, JSON.stringify(entry), {
+      expirationTtl: Math.ceil(windowMs / 1e3) + 60
+    });
+  }
+}
+async function clearRateLimit(env, ip) {
+  const kvKey = `rate:${ip}`;
+  await env.KV.delete(kvKey);
+}
+async function getAuthStore(env) {
+  const store = await env.KV.get(AUTH_KV, "json");
+  return store;
+}
+async function setupAuth(env, username, password) {
+  const salt = await generateSalt();
+  const passwordHash = await hashPassword(password, salt);
+  await env.KV.put(AUTH_KV, JSON.stringify({
+    username,
+    passwordHash,
+    salt
+  }));
+}
+async function verifyCredentials(env, username, password) {
+  const store = await getAuthStore(env);
+  if (!store) {
+    return false;
+  }
+  if (username !== store.username) {
+    return false;
+  }
+  const hash = await hashPassword(password, store.salt);
+  return hash === store.passwordHash;
+}
+function getClientIP(request) {
+  return request.headers.get("CF-Connecting-IP") || request.headers.get("X-Forwarded-For")?.split(",")[0]?.trim() || "unknown";
+}
+function getSessionToken(request) {
+  const cookieHeader = request.headers.get("Cookie");
+  if (!cookieHeader) return null;
+  const match = cookieHeader.split(";").find((c) => c.trim().startsWith("session="));
+  return match?.split("=")[1] || null;
+}
+async function handleContent(request, env, subpath) {
+  const bucket = env.CONTENT_BUCKET;
+  if (!bucket) {
+    return createErrorResponse("Content bucket not configured", 500);
+  }
+  const method = request.method;
+  const clientIP = getClientIP(request);
+  const rateCheck = await checkRateLimit(env, clientIP);
+  if (!rateCheck.allowed) {
+    return new Response(JSON.stringify({
+      error: "Too many failed attempts. Please wait.",
+      retryAfter: Math.ceil(rateCheck.delayMs / 1e3)
+    }), {
+      status: 429,
+      headers: {
+        "Content-Type": "application/json",
+        "Retry-After": String(Math.ceil(rateCheck.delayMs / 1e3))
+      }
+    });
+  }
+  if (method === "GET" && subpath.startsWith("images/")) {
+    return handleGet(request, bucket, subpath);
+  }
+  const store = await getAuthStore(env);
+  if (!store) {
+    if (method === "GET") {
+      return handleGet(request, bucket, subpath);
+    }
+    return createErrorResponse("Admin not configured. Use POST /auth/setup to configure.", 401);
+  }
+  const sessionToken = getSessionToken(request) || request.headers.get("X-Session-Token");
+  let isAuthenticated = false;
+  if (sessionToken) {
+    const session = await env.KV.get(`session:${sessionToken}`, "json");
+    if (session && session.expiresAt > Date.now()) {
+      isAuthenticated = true;
+    }
+  }
+  const authHeader = request.headers.get("Authorization");
+  if (!isAuthenticated && authHeader?.startsWith("Basic ")) {
+    try {
+      const credentials = atob(authHeader.slice(6));
+      const [username, password] = credentials.split(":");
+      if (await verifyCredentials(env, username, password)) {
+        isAuthenticated = true;
+      }
+    } catch (e) {
+    }
+  }
+  if (!isAuthenticated) {
+    await recordFailedAttempt(env, clientIP);
+    return createErrorResponse("Unauthorized", 401);
+  }
+  await clearRateLimit(env, clientIP);
+  if (method === "GET") {
+    return handleGet(request, bucket, subpath);
+  }
+  return handleWrite(request, bucket, subpath, env, method);
+}
+async function handleGet(request, bucket, subpath) {
+  if (request.method === "GET" && (!subpath || subpath === "/")) {
+    try {
+      const list = await bucket.list();
+      return createJSONResponse(list.objects.map((o) => ({
+        key: o.key,
+        size: o.size,
+        uploaded: o.uploaded,
+        httpEtag: o.httpEtag
+      })));
+    } catch (e) {
+      return createErrorResponse("Failed to list content: " + e.message, 500);
+    }
+  }
+  if (request.method === "GET" && subpath) {
+    try {
+      const object = await bucket.get(subpath);
+      if (!object) {
+        return createErrorResponse("Content not found", 404);
+      }
+      const headers = new Headers();
+      object.writeHttpMetadata(headers);
+      headers.set("etag", object.httpEtag);
+      return new Response(object.body, { headers });
+    } catch (e) {
+      return createErrorResponse("Failed to get content: " + e.message, 500);
+    }
+  }
+  return createErrorResponse("Method not allowed", 405);
+}
+async function handleWrite(request, bucket, subpath, env, method) {
+  if (method === "PUT" && subpath) {
+    try {
+      const contentType = request.headers.get("Content-Type");
+      const options = {};
+      if (contentType) {
+        options.httpMetadata = { contentType };
+      }
+      await bucket.put(subpath, request.body, options);
+      clearContentCache();
+      clearContentCache$1();
+      return createJSONResponse({ success: true, key: subpath });
+    } catch (e) {
+      return createErrorResponse("Failed to upload content: " + e.message, 500);
+    }
+  }
+  if (method === "DELETE" && subpath) {
+    try {
+      await bucket.delete(subpath);
+      clearContentCache();
+      clearContentCache$1();
+      return createJSONResponse({ success: true, key: subpath });
+    } catch (e) {
+      return createErrorResponse("Failed to delete content: " + e.message, 500);
+    }
+  }
+  return createErrorResponse("Method not allowed", 405);
+}
+function createSessionCookie(token, origin) {
+  const expires = new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3).toUTCString();
+  const isSecure = origin.startsWith("https://");
+  const hostname = new URL(origin).hostname;
+  const SameSite = isSecure ? "Strict" : "Lax";
+  let cookie = `session=${token}; HttpOnly; SameSite=${SameSite}; Path=/; Expires=${expires}`;
+  if (isSecure) {
+    cookie += "; Secure";
+  }
+  cookie += `; Domain=${hostname}`;
+  return cookie;
+}
+async function handleAuth(request, env, subpath) {
+  request.method;
+  const clientIP = getClientIP(request);
+  const path = subpath.replace(/^\//, "").split("/")[0];
+  const origin = request.headers.get("Origin") || new URL(request.url).origin;
+  const rateCheck = await checkRateLimit(env, clientIP);
+  if (!rateCheck.allowed) {
+    return new Response(JSON.stringify({
+      error: "Too many failed attempts. Please wait.",
+      retryAfter: Math.ceil(rateCheck.delayMs / 1e3)
+    }), {
+      status: 429,
+      headers: {
+        "Content-Type": "application/json",
+        "Retry-After": String(Math.ceil(rateCheck.delayMs / 1e3))
+      }
+    });
+  }
+  switch (path) {
+    case "setup":
+      return handleSetup(request, env, clientIP, origin);
+    case "status":
+      return handleStatus(env);
+    case "login":
+      return handleLogin(request, env, clientIP, origin);
+    case "logout":
+      return handleLogout(request, env);
+    default:
+      return createErrorResponse("Not found", 404);
+  }
+}
+async function handleSetup(request, env, clientIP, origin) {
+  console.log("handleSetup: starting setup, env.KV exists:", !!env.KV);
+  if (request.method !== "POST") {
+    return createErrorResponse("Method not allowed", 405);
+  }
+  try {
+    const existing = await getAuthStore(env);
+    console.log("handleSetup: existing store check:", !!existing);
+    if (existing) {
+      return createErrorResponse("Admin already configured. Use /auth/login to login.", 400);
+    }
+    const body = await request.json();
+    const { username, password } = body;
+    console.log("handleSetup: body parsed, username:", username);
+    if (!username || !password) {
+      return createErrorResponse("Username and password required", 400);
+    }
+    if (username.length < 3 || password.length < 8) {
+      return createErrorResponse("Username must be 3+ chars, password must be 8+ chars", 400);
+    }
+    console.log("handleSetup: calling setupAuth");
+    await setupAuth(env, username, password);
+    console.log("handleSetup: setupAuth successful");
+    await clearRateLimit(env, clientIP);
+    const token = crypto.randomUUID();
+    console.log("handleSetup: session token generated");
+    await env.KV.put(`session:${token}`, JSON.stringify({
+      createdAt: Date.now(),
+      expiresAt: Date.now() + 7 * 24 * 60 * 60 * 1e3
+    }), { expirationTtl: 7 * 24 * 60 * 60 });
+    console.log("handleSetup: session stored in KV");
+    const headers = {
+      "Content-Type": "application/json",
+      "Set-Cookie": createSessionCookie(token, origin),
+      "X-Session-Token": token
+    };
+    return new Response(JSON.stringify({
+      success: true,
+      message: "Admin configured successfully"
+    }), {
+      status: 201,
+      headers
+    });
+  } catch (e) {
+    console.error("handleSetup: error occurred:", e);
+    return createErrorResponse("Internal server error: " + e.message, 500);
+  }
+}
+async function handleStatus(env) {
+  const store = await getAuthStore(env);
+  return createJSONResponse({
+    configured: !!store,
+    username: store?.username || null
+  });
+}
+async function handleLogin(request, env, clientIP, origin) {
+  if (request.method !== "POST") {
+    return createErrorResponse("Method not allowed", 405);
+  }
+  const store = await getAuthStore(env);
+  if (!store) {
+    return createErrorResponse("Admin not configured. Use POST /auth/setup first.", 401);
+  }
+  try {
+    const body = await request.json();
+    const { username, password } = body;
+    if (!username || !password) {
+      return createErrorResponse("Username and password required", 400);
+    }
+    if (await verifyCredentials(env, username, password)) {
+      await clearRateLimit(env, clientIP);
+      const token = crypto.randomUUID();
+      await env.KV.put(`session:${token}`, JSON.stringify({
+        createdAt: Date.now(),
+        expiresAt: Date.now() + 7 * 24 * 60 * 60 * 1e3
+      }), { expirationTtl: 7 * 24 * 60 * 60 });
+      const headers = {
+        "Content-Type": "application/json",
+        "Set-Cookie": createSessionCookie(token, origin),
+        "X-Session-Token": token
+      };
+      return new Response(JSON.stringify({
+        success: true,
+        message: "Login successful"
+      }), {
+        status: 200,
+        headers
+      });
+    } else {
+      await recordFailedAttempt(env, clientIP);
+      return createErrorResponse("Invalid credentials", 401);
+    }
+  } catch (e) {
+    return createErrorResponse("Invalid request body", 400);
+  }
+}
+async function handleLogout(request, env) {
+  if (request.method !== "POST") {
+    return createErrorResponse("Method not allowed", 405);
+  }
+  const origin = request.headers.get("Origin") || new URL(request.url).origin;
+  const cookieHeader = request.headers.get("Cookie");
+  const sessionToken = cookieHeader?.split(";").find((c) => c.trim().startsWith("session="))?.split("=")[1];
+  if (sessionToken) {
+    await env.KV.delete(`session:${sessionToken}`);
+  }
+  const hostname = new URL(origin).hostname;
+  const isSecure = origin.startsWith("https://");
+  const SameSite = isSecure ? "Strict" : "Lax";
+  const logoutCookie = `session=; HttpOnly; SameSite=${SameSite}; Path=/; Max-Age=0; Domain=${hostname}${isSecure ? "; Secure" : ""}`;
+  return new Response(JSON.stringify({ success: true, message: "Logged out" }), {
+    status: 200,
+    headers: {
+      "Content-Type": "application/json",
+      "Set-Cookie": logoutCookie
+    }
+  });
+}
+const contentCache = /* @__PURE__ */ new Map();
+const CACHE_TTL = 5 * 60 * 1e3;
+function getCachedOrFetch(key, fetchFn) {
+  const cached = contentCache.get(key);
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+    return Promise.resolve(cached.data);
+  }
+  return fetchFn().then((data) => {
+    contentCache.set(key, { data, timestamp: Date.now() });
+    return data;
+  });
+}
+function parseFrontmatter(content) {
+  const lines = content.split("\n");
+  const metadata = {};
+  let contentStart = 0;
+  if (lines[0]?.trim() === "---") {
+    for (let i = 1; i < lines.length; i++) {
+      if (lines[i]?.trim() === "---") {
+        contentStart = i + 1;
+        break;
+      }
+      const colonIdx = lines[i].indexOf(":");
+      if (colonIdx > 0) {
+        const key = lines[i].slice(0, colonIdx).trim();
+        let value = lines[i].slice(colonIdx + 1).trim();
+        if (value.startsWith("[") && value.endsWith("]")) {
+          value = value.slice(1, -1);
+          metadata[key] = value.split(",").map((v) => v.trim());
+        } else {
+          metadata[key] = value;
+        }
+      }
+    }
+  }
+  return {
+    metadata,
+    content: lines.slice(contentStart).join("\n").trim()
+  };
+}
+function checkContentBucket(env) {
+  if (!env?.CONTENT_BUCKET) {
+    return createErrorResponse("Content bucket not configured", 500);
+  }
+  return null;
+}
+async function fetchContentItem(bucket, type, slug) {
+  const mdObj = await bucket.get(`${type}/${slug}.md`);
+  const jsonObj = await bucket.get(`${type}/${slug}.json`);
+  if (!mdObj && !jsonObj) throw new Error(`${type.slice(0, -1)} not found`);
+  let metadata = {};
+  if (jsonObj) {
+    metadata = await jsonObj.json();
+  }
+  let content = "";
+  if (mdObj) {
+    const text = await mdObj.text();
+    const parsed = parseFrontmatter(text);
+    content = parsed.content;
+    metadata = { ...parsed.metadata, ...metadata };
+  }
+  return { ...metadata, slug, content };
+}
+async function fetchContentList(bucket, type, latest) {
+  const list = await bucket.list({ prefix: `${type}/` });
+  const items = [];
+  for (const item of list.objects) {
+    if (item.key.endsWith(".json")) {
+      const obj = await bucket.get(item.key);
+      if (obj) {
+        const metadata = await obj.json();
+        const slug = item.key.replace(`${type}/`, "").replace(".json", "");
+        items.push({ ...metadata, slug });
+      }
+    }
+  }
+  const sorted = items.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
+  return latest ? sorted.slice(0, latest) : sorted;
+}
+async function searchContent(bucket, query) {
+  const q = query.toLowerCase();
+  const results = [];
+  const [blogsList, storiesList] = await Promise.all([
+    bucket.list({ prefix: "blogs/" }),
+    bucket.list({ prefix: "stories/" })
+  ]);
+  for (const item of [...blogsList.objects, ...storiesList.objects]) {
+    if (item.key.endsWith(".md")) {
+      const obj = await bucket.get(item.key);
+      if (obj) {
+        const text = await obj.text();
+        const { metadata } = parseFrontmatter(text);
+        const matchTitle = metadata.title?.toLowerCase().includes(q);
+        const matchDesc = metadata.description?.toLowerCase().includes(q);
+        const matchTags = metadata.tags?.some((t) => t.toLowerCase().includes(q));
+        if (matchTitle || matchDesc || matchTags) {
+          results.push(metadata);
+        }
+      }
+    }
+  }
+  return results;
+}
+async function handleBlogs(env, slug, latest) {
+  const bucketCheck = checkContentBucket(env);
+  if (bucketCheck) return bucketCheck;
+  try {
+    const cacheKey = slug ? `blog-${slug}` : `blogs-list-${latest || "all"}`;
+    const result = await getCachedOrFetch(cacheKey, async () => {
+      if (slug) {
+        return await fetchContentItem(env.CONTENT_BUCKET, "blogs", slug);
+      }
+      return await fetchContentList(env.CONTENT_BUCKET, "blogs", latest);
+    });
+    return createJSONResponse(result);
+  } catch (error) {
+    console.error("Error serving blogs:", error);
+    return createErrorResponse("Blog not found", 404);
+  }
+}
+async function handleStories(env, slug, latest) {
+  const bucketCheck = checkContentBucket(env);
+  if (bucketCheck) return bucketCheck;
+  try {
+    const cacheKey = slug ? `story-${slug}` : `stories-list-${latest || "all"}`;
+    const result = await getCachedOrFetch(cacheKey, async () => {
+      if (slug) {
+        return await fetchContentItem(env.CONTENT_BUCKET, "stories", slug);
+      }
+      return await fetchContentList(env.CONTENT_BUCKET, "stories", latest);
+    });
+    return createJSONResponse(result);
+  } catch (error) {
+    console.error("Error serving stories:", error);
+    return createErrorResponse("Story not found", 404);
+  }
+}
+async function handleSearch(env, query) {
+  const bucketCheck = checkContentBucket(env);
+  if (bucketCheck) return bucketCheck;
+  if (!query) {
+    return createErrorResponse("Search query required", 400);
+  }
+  try {
+    const searchResults = await getCachedOrFetch(`search-${query}`, async () => {
+      return await searchContent(env.CONTENT_BUCKET, query);
+    });
+    return createJSONResponse(searchResults);
+  } catch (error) {
+    console.error("Error serving search:", error);
+    return createErrorResponse("Search failed", 500);
+  }
+}
+const PLACEHOLDER_LOGO = `<svg width="600" height="320" viewBox="0 0 600 320" xmlns="http://www.w3.org/2000/svg">
+  <style>
+    .text-main { 
+      fill: light-dark(#4A5568, #E2E8F0);
+      font-family: 'Segoe UI', 'Arial Black', sans-serif; 
+      font-weight: 900; 
+      font-size: 46px; 
+      letter-spacing: -0.01em; 
+      text-anchor: middle; 
+    }
+  </style>
+
+  <!-- Big circle placeholder -->
+  <circle cx="300" cy="160" r="100" fill="none" stroke="light-dark(#A0AEC0, #718096)" stroke-width="2" stroke-dasharray="8 4" opacity="0.5" />
+  
+  <!-- Plus sign in circle -->
+  <line x1="300" y1="100" x2="300" y2="220" stroke="light-dark(#A0AEC0, #718096)" stroke-width="2" opacity="0.3" />
+  <line x1="240" y1="160" x2="360" y2="160" stroke="light-dark(#A0AEC0, #718096)" stroke-width="2" opacity="0.3" />
+
+  <text x="300" y="290" class="text-main">YOUR LOGO</text>
+</svg>`;
+async function handleLogo(env) {
+  try {
+    if (env?.CONTENT_BUCKET) {
+      const logo = await env.CONTENT_BUCKET.get("logo.svg");
+      if (logo) {
+        const headers = new Headers();
+        logo.writeHttpMetadata(headers);
+        headers.set("Content-Type", "image/svg+xml");
+        headers.set("Cache-Control", "public, max-age=3600");
+        headers.set("Access-Control-Allow-Origin", "*");
+        return new Response(logo.body, { headers });
+      }
+    }
+    return new Response(PLACEHOLDER_LOGO, {
+      headers: {
+        "Content-Type": "image/svg+xml",
+        "Cache-Control": "public, max-age=3600",
+        "Access-Control-Allow-Origin": "*"
+      }
+    });
+  } catch (error) {
+    console.error("Error serving logo:", error);
+    return new Response(PLACEHOLDER_LOGO, {
+      headers: {
+        "Content-Type": "image/svg+xml",
+        "Access-Control-Allow-Origin": "*"
+      }
+    });
+  }
+}
+const DEFAULT_STATIC_DETAILS = {
+  siteTitle: "My Personal Website",
+  copyright: "2026 My Personal Website",
+  linkedin: "https://linkedin.com/in/yourname",
+  github: "https://github.com/yourname",
+  email: "yourname@domain.com"
+};
+async function handleStaticDetails(env, method, body) {
+  try {
+    if (!env?.CONTENT_BUCKET) {
+      return new Response(JSON.stringify(DEFAULT_STATIC_DETAILS), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    if (!method || method === "GET") {
+      const staticDetails = await env.CONTENT_BUCKET.get("static-details.json");
+      if (staticDetails) {
+        const data = await staticDetails.json();
+        return new Response(JSON.stringify({ ...DEFAULT_STATIC_DETAILS, ...data }), {
+          headers: {
+            "Content-Type": "application/json",
+            "Access-Control-Allow-Origin": "*"
+          }
+        });
+      }
+      return new Response(JSON.stringify(DEFAULT_STATIC_DETAILS), {
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*"
+        }
+      });
+    }
+    return new Response(JSON.stringify({ error: "Use content endpoint for PUT" }), {
+      status: 400,
+      headers: { "Content-Type": "application/json" }
+    });
+  } catch (error) {
+    console.error("Error serving static details:", error);
+    return new Response(JSON.stringify(DEFAULT_STATIC_DETAILS), {
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+}
+class WebsiteAPI {
+  constructor() {
+    this.customHandlers = /* @__PURE__ */ new Map();
+  }
+  registerHandler(route, handler) {
+    this.customHandlers.set(route, handler);
+  }
+  addCORSHeaders(response) {
+    response.headers.set("Access-Control-Allow-Origin", "*");
+    response.headers.set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+    response.headers.set("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Session-Token");
+    return response;
+  }
+  addAdminCORSHeaders(response, origin) {
+    const allowOrigin = origin && (origin.includes("localhost") || origin.includes("127.0.0.1")) ? origin : "same-origin";
+    response.headers.set("Access-Control-Allow-Origin", allowOrigin);
+    response.headers.set("Access-Control-Allow-Credentials", "true");
+    response.headers.set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+    response.headers.set("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Session-Token");
+    return response;
+  }
+  handleCORS(origin) {
+    const allowOrigin = origin && (origin.includes("localhost") || origin.includes("127.0.0.1")) ? origin : "*";
+    return new Response(null, {
+      status: 200,
+      headers: {
+        "Access-Control-Allow-Origin": allowOrigin,
+        "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Session-Token",
+        "Access-Control-Allow-Credentials": "true",
+        "Access-Control-Max-Age": "86400"
+      }
+    });
+  }
+  async fetch(request, env) {
+    const url = new URL(request.url);
+    const origin = request.headers.get("Origin") || url.origin;
+    if (request.method === "OPTIONS") {
+      return this.handleCORS(origin);
+    }
+    const pathname = url.pathname;
+    const route = pathname.replace(/^\/api\//, "").replace(/^\//, "").replace(/\/+$/, "");
+    if (this.customHandlers.has(route)) {
+      const handler = this.customHandlers.get(route);
+      return this.addCORSHeaders(await handler(request, env));
+    }
+    try {
+      if (route === "content" || route.startsWith("content/")) {
+        const subpath = route.replace(/^content\/?/, "");
+        return this.addAdminCORSHeaders(await handleContent(request, env, subpath), origin);
+      }
+      if (route === "auth" || route.startsWith("auth/")) {
+        const subpath = route.replace(/^auth\/?/, "");
+        return this.addAdminCORSHeaders(await handleAuth(request, env, subpath || "/"), origin);
+      }
+      switch (route) {
+        case "info":
+          return this.addCORSHeaders(await handleInfo());
+        case "home":
+          return this.addAdminCORSHeaders(await handleHome(env), origin);
+        case "cache-clear":
+          const cookieHeader = request.headers.get("Cookie");
+          const sessionToken = cookieHeader?.split(";").find((c) => c.trim().startsWith("session="))?.split("=")[1];
+          const session = sessionToken ? await env.KV.get(`session:${sessionToken}`, "json") : null;
+          if (!session || session.expiresAt < Date.now()) {
+            return this.addAdminCORSHeaders(createErrorResponse("Unauthorized", 401), origin);
+          }
+          clearContentCache$1();
+          return this.addAdminCORSHeaders(new Response(JSON.stringify({ success: true, message: "Cache cleared" }), { status: 200 }), origin);
+        case "aboutme":
+          return this.addAdminCORSHeaders(await handleAboutMe(env), origin);
+        case "logo":
+          return this.addAdminCORSHeaders(await handleLogo(env), origin);
+        case "static":
+          return this.addAdminCORSHeaders(await handleStaticDetails(env), origin);
+        case "blogs":
+          return this.addAdminCORSHeaders(await handleBlogs(env), origin);
+        case "blogs/latest":
+          const latestCount = url.searchParams.get("count");
+          return this.addAdminCORSHeaders(await handleBlogs(env, void 0, latestCount ? parseInt(latestCount) : 5), origin);
+        default:
+          if (route.startsWith("images/")) {
+            return this.addAdminCORSHeaders(await handleContent(request, env, route), origin);
+          }
+          if (route.startsWith("blogs/")) {
+            const slug = route.replace("blogs/", "");
+            return this.addAdminCORSHeaders(await handleBlogs(env, slug), origin);
+          }
+          if (route.startsWith("stories")) {
+            if (route === "stories") {
+              return this.addAdminCORSHeaders(await handleStories(env), origin);
+            }
+            if (route === "stories/latest") {
+              const latestCount2 = url.searchParams.get("count");
+              return this.addAdminCORSHeaders(await handleStories(env, void 0, latestCount2 ? parseInt(latestCount2) : 5), origin);
+            }
+            const slug = route.replace("stories/", "");
+            return this.addAdminCORSHeaders(await handleStories(env, slug), origin);
+          }
+          if (route === "search") {
+            const query = url.searchParams.get("q");
+            return this.addAdminCORSHeaders(await handleSearch(env, query || void 0), origin);
+          }
+          return this.addAdminCORSHeaders(createErrorResponse("Route not found", 404), origin);
+      }
+    } catch (error) {
+      console.error("API Error:", error);
+      return this.addCORSHeaders(createErrorResponse("Internal server error", 500));
+    }
+  }
+}
+export {
+  AUTH_KV as A,
+  BASE_DELAY_MS as B,
+  MAX_ATTEMPTS as M,
+  RATE_LIMIT_KV as R,
+  WebsiteAPI as W,
+  clearRateLimit as a,
+  getAuthStore as b,
+  checkRateLimit as c,
+  getClientIP as d,
+  hashPassword as e,
+  generateSalt as g,
+  handleAuth as h,
+  recordFailedAttempt as r,
+  setupAuth as s,
+  verifyCredentials as v
+};