@leadertechie/personal-site-kit 0.1.0-alpha.7 → 0.1.0-alpha.9

package/src/api/handlers/auth.ts

@@ -1,157 +0,0 @@
-const AUTH_KV = 'auth_store';
-const RATE_LIMIT_KV = 'rate_limit';
-const MAX_ATTEMPTS = 5;
-const BASE_DELAY_MS = 1000; // 1 second
-const MAX_DELAY_MS = 60000; // 1 minute
-
-interface AuthStore {
-  username: string;
-  passwordHash: string;
-  salt: string;
-}
-
-interface RateLimitEntry {
-  attempts: number;
-  firstAttempt: number;
-  lastAttempt: number;
-}
-
-async function hashPassword(password: string, salt: string): Promise<string> {
-  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: 100000,
-      hash: 'SHA-256'
-    },
-    keyMaterial,
-    256
-  );
-  
-  return btoa(String.fromCharCode(...new Uint8Array(derivedBits)));
-}
-
-async function generateSalt(): Promise<string> {
-  const saltBytes = crypto.getRandomValues(new Uint8Array(16));
-  return btoa(String.fromCharCode(...saltBytes));
-}
-
-async function checkRateLimit(env: any, ip: string): Promise<{ allowed: boolean; delayMs: number }> {
-  const kvKey = `rate:${ip}`;
-  const entry = await env.KV.get(kvKey, 'json') as RateLimitEntry | null;
-  
-  if (!entry) {
-    return { allowed: true, delayMs: 0 };
-  }
-  
-  const now = Date.now();
-  const windowMs = 15 * 60 * 1000; // 15 minute window
-  
-  // Reset if window expired
-  if (now - entry.firstAttempt > windowMs) {
-    return { allowed: true, delayMs: 0 };
-  }
-  
-  // Check if exceeded max attempts
-  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: any, ip: string): Promise<void> {
-  const kvKey = `rate:${ip}`;
-  const entry = await env.KV.get(kvKey, 'json') as RateLimitEntry | null;
-  
-  const now = Date.now();
-  const windowMs = 15 * 60 * 1000;
-  
-  if (!entry || now - entry.firstAttempt > windowMs) {
-    // Start new window
-    await env.KV.put(kvKey, JSON.stringify({
-      attempts: 1,
-      firstAttempt: now,
-      lastAttempt: now
-    }), { expirationTtl: Math.ceil(windowMs / 1000) + 60 });
-  } else {
-    entry.attempts++;
-    entry.lastAttempt = now;
-    await env.KV.put(kvKey, JSON.stringify(entry), { 
-      expirationTtl: Math.ceil(windowMs / 1000) + 60 
-    });
-  }
-}
-
-async function clearRateLimit(env: any, ip: string): Promise<void> {
-  const kvKey = `rate:${ip}`;
-  await env.KV.delete(kvKey);
-}
-
-async function getAuthStore(env: any): Promise<AuthStore | null> {
-  const store = await env.KV.get(AUTH_KV, 'json') as AuthStore | null;
-  return store;
-}
-
-async function setupAuth(env: any, username: string, password: string): Promise<void> {
-  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: any, username: string, password: string): Promise<boolean> {
-  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: Request): string {
-  return request.headers.get('CF-Connecting-IP') || 
-         request.headers.get('X-Forwarded-For')?.split(',')[0]?.trim() ||
-         'unknown';
-}
-
-export { 
-  hashPassword, 
-  generateSalt, 
-  checkRateLimit, 
-  recordFailedAttempt, 
-  clearRateLimit,
-  getAuthStore,
-  setupAuth,
-  verifyCredentials,
-  getClientIP,
-  AUTH_KV,
-  RATE_LIMIT_KV,
-  MAX_ATTEMPTS,
-  BASE_DELAY_MS
-};

package/src/api/handlers/content-api.ts

@@ -1,268 +0,0 @@
-// Content handler for blogs, stories, and search
-
-interface ContentMetadata {
-  slug: string;
-  title: string;
-  description: string;
-  summary?: string;
-  date: string;
-  imageUrl?: string;
-  tags?: string[];
-  author?: string;
-}
-
-interface BlogPost extends ContentMetadata {
-  content: string;
-}
-
-interface StoryPost extends ContentMetadata {
-  content: string;
-}
-
-// In-memory cache for content (reduces R2 reads)
-const contentCache = new Map<string, { data: any; timestamp: number }>();
-const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
-
-async function getCachedOrFetch<T>(key: string, fetchFn: () => Promise<T>): Promise<T> {
-  const cached = contentCache.get(key);
-  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
-    return cached.data as T;
-  }
-  const data = await fetchFn();
-  contentCache.set(key, { data, timestamp: Date.now() });
-  return data;
-}
-
-function clearCache(prefix?: string): void {
-  if (prefix) {
-    for (const key of contentCache.keys()) {
-      if (key.startsWith(prefix)) {
-        contentCache.delete(key);
-      }
-    }
-  } else {
-    contentCache.clear();
-  }
-}
-
-function parseFrontmatter(content: string): { metadata: ContentMetadata; content: string } {
-  const lines = content.split('\n');
-  const metadata: Record<string, string | string[]> = {};
-  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: metadata as unknown as ContentMetadata,
-    content: lines.slice(contentStart).join('\n').trim()
-  };
-}
-
-export async function handleBlogs(env?: any, slug?: string, latest?: number): Promise<Response> {
-  try {
-    if (!env?.CONTENT_BUCKET) {
-      return new Response(JSON.stringify({ error: 'Content bucket not configured' }), {
-        status: 500,
-        headers: { 'Content-Type': 'application/json' },
-      });
-    }
-
-    const cacheKey = slug ? `blog-${slug}` : `blogs-list-${latest || 'all'}`;
-    
-    const result = await getCachedOrFetch(cacheKey, async () => {
-      if (slug) {
-        // Fetch content from .md file
-        const mdObj = await env.CONTENT_BUCKET.get(`blogs/${slug}.md`);
-        const jsonObj = await env.CONTENT_BUCKET.get(`blogs/${slug}.json`);
-        
-        if (!mdObj && !jsonObj) throw new Error('Blog not found');
-        
-        let metadata: any = {};
-        if (jsonObj) {
-          metadata = await jsonObj.json();
-        }
-        
-        let content = '';
-        if (mdObj) {
-          const text = await mdObj.text();
-          const parsed = parseFrontmatter(text);
-          content = parsed.content;
-          // Merge metadata from frontmatter if not in JSON
-          metadata = { ...parsed.metadata, ...metadata };
-        }
-        
-        return { ...metadata, slug, content } as BlogPost;
-      }
-
-      const list = await env.CONTENT_BUCKET.list({ prefix: 'blogs/' });
-      const blogs: ContentMetadata[] = [];
-      
-      for (const item of list.objects) {
-        if (item.key.endsWith('.json')) {
-          const obj = await env.CONTENT_BUCKET.get(item.key);
-          if (obj) {
-            const metadata = await obj.json() as ContentMetadata;
-            const slug = item.key.replace('blogs/', '').replace('.json', '');
-            blogs.push({ ...metadata, slug });
-          }
-        }
-      }
-
-      const sorted = blogs.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
-      return latest ? sorted.slice(0, latest) : sorted;
-    });
-
-    return new Response(JSON.stringify(result), {
-      headers: { 'Content-Type': 'application/json' },
-    });
-  } catch (error) {
-    console.error('Error serving blogs:', error);
-    return new Response(JSON.stringify({ error: 'Blog not found' }), {
-      status: 404,
-      headers: { 'Content-Type': 'application/json' },
-    });
-  }
-}
-
-export async function handleStories(env?: any, slug?: string, latest?: number): Promise<Response> {
-  try {
-    if (!env?.CONTENT_BUCKET) {
-      return new Response(JSON.stringify({ error: 'Content bucket not configured' }), {
-        status: 500,
-        headers: { 'Content-Type': 'application/json' },
-      });
-    }
-
-    const cacheKey = slug ? `story-${slug}` : `stories-list-${latest || 'all'}`;
-    
-    const result = await getCachedOrFetch(cacheKey, async () => {
-      if (slug) {
-        const mdObj = await env.CONTENT_BUCKET.get(`stories/${slug}.md`);
-        const jsonObj = await env.CONTENT_BUCKET.get(`stories/${slug}.json`);
-        
-        if (!mdObj && !jsonObj) throw new Error('Story not found');
-        
-        let metadata: any = {};
-        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 } as StoryPost;
-      }
-
-      const list = await env.CONTENT_BUCKET.list({ prefix: 'stories/' });
-      const stories: ContentMetadata[] = [];
-      
-      for (const item of list.objects) {
-        if (item.key.endsWith('.json')) {
-          const obj = await env.CONTENT_BUCKET.get(item.key);
-          if (obj) {
-            const metadata = await obj.json() as ContentMetadata;
-            const slug = item.key.replace('stories/', '').replace('.json', '');
-            stories.push({ ...metadata, slug });
-          }
-        }
-      }
-
-      const sorted = stories.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
-      return latest ? sorted.slice(0, latest) : sorted;
-    });
-
-    return new Response(JSON.stringify(result), {
-      headers: { 'Content-Type': 'application/json' },
-    });
-  } catch (error) {
-    console.error('Error serving stories:', error);
-    return new Response(JSON.stringify({ error: 'Story not found' }), {
-      status: 404,
-      headers: { 'Content-Type': 'application/json' },
-    });
-  }
-}
-
-export async function handleSearch(env?: any, query?: string): Promise<Response> {
-  try {
-    if (!env?.CONTENT_BUCKET) {
-      return new Response(JSON.stringify({ error: 'Content bucket not configured' }), {
-        status: 500,
-        headers: { 'Content-Type': 'application/json' },
-      });
-    }
-
-    if (!query) {
-      return new Response(JSON.stringify({ error: 'Search query required' }), {
-        status: 400,
-        headers: { 'Content-Type': 'application/json' },
-      });
-    }
-
-    const searchResults = await getCachedOrFetch(`search-${query}`, async () => {
-      const q = query.toLowerCase();
-      const results: (BlogPost | StoryPost)[] = [];
-      
-      const [blogsList, storiesList] = await Promise.all([
-        env.CONTENT_BUCKET.list({ prefix: 'blogs/' }),
-        env.CONTENT_BUCKET.list({ prefix: 'stories/' })
-      ]);
-
-      for (const item of [...blogsList.objects, ...storiesList.objects]) {
-        if (item.key.endsWith('.md')) {
-          const obj = await env.CONTENT_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: string) => t.toLowerCase().includes(q));
-            
-            if (matchTitle || matchDesc || matchTags) {
-              results.push(metadata as BlogPost | StoryPost);
-            }
-          }
-        }
-      }
-
-      return results;
-    });
-
-    return new Response(JSON.stringify(searchResults), {
-      headers: { 'Content-Type': 'application/json' },
-    });
-  } catch (error) {
-    console.error('Error serving search:', error);
-    return new Response(JSON.stringify({ error: 'Search failed' }), {
-      status: 500,
-      headers: { 'Content-Type': 'application/json' },
-    });
-  }
-}
-
-export function clearContentCache(): void {
-  clearCache();
-}

package/src/api/handlers/content.ts

@@ -1,139 +0,0 @@
-import { createJSONResponse, createErrorResponse } from '../utils';
-import { 
-  checkRateLimit, 
-  recordFailedAttempt, 
-  clearRateLimit,
-  verifyCredentials,
-  getClientIP,
-  getAuthStore
-} from './auth';
-
-function getSessionToken(request: Request): string | null {
-  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;
-}
-
-export async function handleContent(request: Request, env: any, subpath: string): Promise<Response> {
-  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 / 1000)
-    }), {
-      status: 429,
-      headers: { 
-        'Content-Type': 'application/json',
-        'Retry-After': String(Math.ceil(rateCheck.delayMs / 1000))
-      }
-    });
-  }
-
-  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);
-  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: Request, bucket: any, subpath: string): Promise<Response> {
-  if (request.method === 'GET' && (!subpath || subpath === '/')) {
-    try {
-      const list = await bucket.list();
-      return createJSONResponse(list.objects.map((o: any) => ({
-        key: o.key,
-        size: o.size,
-        uploaded: o.uploaded,
-        httpEtag: o.httpEtag
-      })));
-    } catch (e: any) {
-      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: any) {
-      return createErrorResponse('Failed to get content: ' + e.message, 500);
-    }
-  }
-
-  return createErrorResponse('Method not allowed', 405);
-}
-
-async function handleWrite(request: Request, bucket: any, subpath: string, env: any, method: string): Promise<Response> {
-  if (method === 'PUT' && subpath) {
-    try {
-      await bucket.put(subpath, request.body);
-      return createJSONResponse({ success: true, key: subpath });
-    } catch (e: any) {
-      return createErrorResponse('Failed to upload content: ' + e.message, 500);
-    }
-  }
-
-  if (method === 'DELETE' && subpath) {
-    try {
-      await bucket.delete(subpath);
-      return createJSONResponse({ success: true, key: subpath });
-    } catch (e: any) {
-      return createErrorResponse('Failed to delete content: ' + e.message, 500);
-    }
-  }
-
-  return createErrorResponse('Method not allowed', 405);
-}

package/src/api/handlers/home.ts

@@ -1,79 +0,0 @@
-// Home page content handler
-
-import { R2ContentLoader, type ContentNode } from '@leadertechie/r2tohtml';
-
-interface HomeApiResponse {
-  contentNodes: ContentNode[];
-  processedMarkdown: string;
-  content: string;
-}
-
-let loader: R2ContentLoader | null = null;
-
-function getLoader(env: any): R2ContentLoader {
-  if (!loader && env?.CONTENT_BUCKET) {
-    loader = new R2ContentLoader(
-      {
-        bucket: env.CONTENT_BUCKET,
-        cacheTTL: 5 * 60 * 1000,
-      },
-      {
-        md2html: {
-          imagePathPrefix: 'images/',
-          styleOptions: {
-            classPrefix: 'md-',
-            addHeadingIds: true
-          }
-        }
-      }
-    );
-  }
-  return loader!;
-}
-
-export function clearContentCache() {
-  loader?.clearCache();
-}
-
-export async function handleHome(env?: any): Promise<Response> {
-  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);
-    const [astResult, renderedResult] = await Promise.all([
-      r2.getWithAST('home.md'),
-      r2.getRendered('home.md')
-    ]);
-
-    if (!astResult || !renderedResult) {
-      return new Response(JSON.stringify({
-        contentNodes: [],
-        processedMarkdown: '',
-        content: ''
-      } as HomeApiResponse), {
-        headers: { 'Content-Type': 'application/json' },
-      });
-    }
-
-    const responseData: HomeApiResponse = {
-      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' },
-    });
-  }
-}

package/src/api/handlers/info.ts

@@ -1,12 +0,0 @@
-import { createJSONResponse } from '../utils';
-
-export async function handleInfo(): Promise<Response> {
-  return createJSONResponse({
-    name: 'TechieLeader',
-    version: '1.0.0',
-    description: 'TechieLeader API',
-    endpoints: [
-      { path: '/info', method: 'GET', description: 'Get API information' }
-    ]
-  });
-}