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

package/src/api/__tests__/info.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { handleInfo } from '../handlers/info';
-
-describe('Info Handler', () => {
-  it('should return API information', async () => {
-    const response = await handleInfo();
-
-    expect(response.status).toBe(200);
-    expect(response.headers.get('Content-Type')).toBe('application/json');
-
-    const body = await response.text();
-    const data = JSON.parse(body);
-
-    expect(data.name).toBe('TechieLeader');
-    expect(data.version).toBe('1.0.0');
-    expect(data.description).toBe('TechieLeader API');
-    expect(data.endpoints).toBeInstanceOf(Array);
-    expect(data.endpoints.length).toBeGreaterThan(0);
-  });
-
-  it('should return valid endpoints array', async () => {
-    const response = await handleInfo();
-    const body = await response.text();
-    const data = JSON.parse(body);
-
-    expect(data.endpoints).toContainEqual({
-      path: '/info',
-      method: 'GET',
-      description: 'Get API information'
-    });
-  });
-
-  it('should have correct response structure', async () => {
-    const response = await handleInfo();
-    const body = await response.text();
-    const data = JSON.parse(body);
-
-    expect(data).toHaveProperty('name');
-    expect(data).toHaveProperty('version');
-    expect(data).toHaveProperty('description');
-    expect(data).toHaveProperty('endpoints');
-  });
-});

package/src/api/__tests__/utils.test.ts

@@ -1,78 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { createErrorResponse, createJSONResponse } from '../utils';
-
-describe('Utils', () => {
-  describe('createJSONResponse', () => {
-    it('should create JSON response with data', async () => {
-      const data = { message: 'Hello' };
-      const response = createJSONResponse(data);
-
-      expect(response.status).toBe(200);
-      expect(response.headers.get('Content-Type')).toBe('application/json');
-      
-      const body = await response.text();
-      expect(JSON.parse(body)).toEqual(data);
-    });
-
-    it('should create JSON response with custom status', async () => {
-      const data = { message: 'Not Found' };
-      const response = createJSONResponse(data, 404);
-
-      expect(response.status).toBe(404);
-      expect(response.headers.get('Content-Type')).toBe('application/json');
-    });
-
-    it('should handle empty data', async () => {
-      const response = createJSONResponse(null);
-
-      expect(response.status).toBe(200);
-      const body = await response.text();
-      expect(body).toBe('null');
-    });
-
-    it('should handle complex data structures', async () => {
-      const data = {
-        nested: {
-          array: [1, 2, 3],
-          string: 'test'
-        },
-        number: 42
-      };
-      const response = createJSONResponse(data);
-      
-      const body = await response.text();
-      expect(JSON.parse(body)).toEqual(data);
-    });
-  });
-
-  describe('createErrorResponse', () => {
-    it('should create error response with message', async () => {
-      const response = createErrorResponse('Something went wrong');
-
-      expect(response.status).toBe(500);
-      expect(response.headers.get('Content-Type')).toBe('application/json');
-      
-      const body = await response.text();
-      const parsed = JSON.parse(body);
-      expect(parsed.error).toBe('Something went wrong');
-    });
-
-    it('should create error response with custom status', async () => {
-      const response = createErrorResponse('Not found', 404);
-
-      expect(response.status).toBe(404);
-      expect(response.headers.get('Content-Type')).toBe('application/json');
-      
-      const body = await response.text();
-      const parsed = JSON.parse(body);
-      expect(parsed.error).toBe('Not found');
-    });
-
-    it('should default to status 500 if not provided', () => {
-      const response = createErrorResponse('Error');
-
-      expect(response.status).toBe(500);
-    });
-  });
-});

package/src/api/handlers/about-me.ts

@@ -1,109 +0,0 @@
-// Simple JSON response handler for Cloudflare Workers
-
-import { R2ContentLoader, type ContentNode } from '@leadertechie/r2tohtml';
-
-interface Profile {
-  name: string;
-  title: string;
-  experience: string;
-  profileImageUrl: string;
-}
-
-interface AboutMeApiResponse {
-  profile: Profile;
-  contentNodes: ContentNode[];
-  processedMarkdown: string;
-}
-
-let loader: R2ContentLoader | null = null;
-
-function getLoader(env: any): R2ContentLoader | null {
-  if (!env?.CONTENT_BUCKET) {
-    return null;
-  }
-  
-  if (!loader) {
-    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 handleAboutMe(env?: any): Promise<Response> {
-  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(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: Profile = {
-      name: 'Your Name',
-      title: 'Professional',
-      experience: 'Experienced',
-      profileImageUrl: ''
-    };
-
-    if (profileObj) {
-      profile = await profileObj.json() as Profile;
-    }
-    console.log('handleAboutMe: profile loaded:', profile.name);
-
-    const responseData: AboutMeApiResponse = {
-      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' },
-    });
-  }
-}

package/src/api/handlers/auth-handler.ts

@@ -1,204 +0,0 @@
-import { createJSONResponse, createErrorResponse } from '../utils';
-import { 
-  setupAuth, 
-  getAuthStore,
-  checkRateLimit,
-  recordFailedAttempt,
-  clearRateLimit,
-  verifyCredentials,
-  getClientIP,
-  MAX_ATTEMPTS
-} from './auth';
-
-function createSessionCookie(token: string, origin: string): string {
-  const expires = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).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;
-}
-
-export async function handleAuth(request: Request, env: any, subpath: string): Promise<Response> {
-  const method = request.method;
-  const clientIP = getClientIP(request);
-  const path = subpath.replace(/^\//, '').split('/')[0];
-  const origin = request.headers.get('Origin') || new URL(request.url).origin;
-
-  // Check rate limit for login attempts
-  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))
-      }
-    });
-  }
-
-  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: Request, env: any, clientIP: string, origin: string): Promise<Response> {
-  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 * 1000)
-    }), { expirationTtl: 7 * 24 * 60 * 60 });
-    console.log('handleSetup: session stored in KV');
-
-    const headers: Record<string, string> = {
-      '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 as Error).message, 500);
-  }
-}
-
-async function handleStatus(env: any): Promise<Response> {
-  const store = await getAuthStore(env);
-  
-  return createJSONResponse({
-    configured: !!store,
-    username: store?.username || null
-  });
-}
-
-async function handleLogin(request: Request, env: any, clientIP: string, origin: string): Promise<Response> {
-  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 * 1000)
-      }), { expirationTtl: 7 * 24 * 60 * 60 });
-
-      const headers: Record<string, string> = {
-        '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: Request, env: any): Promise<Response> {
-  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
-    }
-  });
-}

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
-};