anchi-kit 1.2.1 → 1.2.2

package/.cursor/skills/devops/references/cloudflare-workers-apis.md

@@ -1,309 +0,0 @@
-# Cloudflare Workers Runtime APIs
-
-Key runtime APIs for Workers development.
-
-## Fetch API
-
-```typescript
-// Subrequest
-const response = await fetch('https://api.example.com/data', {
-  method: 'POST',
-  headers: { 'Content-Type': 'application/json' },
-  body: JSON.stringify({ key: 'value' }),
-  cf: {
-    cacheTtl: 3600,
-    cacheEverything: true
-  }
-});
-
-const data = await response.json();
-```
-
-## Headers API
-
-```typescript
-// Read headers
-const userAgent = request.headers.get('User-Agent');
-
-// Cloudflare-specific
-const country = request.cf?.country;
-const colo = request.cf?.colo;
-const clientIP = request.headers.get('CF-Connecting-IP');
-
-// Set headers
-const headers = new Headers();
-headers.set('Content-Type', 'application/json');
-headers.append('X-Custom-Header', 'value');
-```
-
-## HTMLRewriter
-
-```typescript
-export default {
-  async fetch(request: Request): Promise<Response> {
-    const response = await fetch(request);
-
-    return new HTMLRewriter()
-      .on('title', {
-        element(element) {
-          element.setInnerContent('New Title');
-        }
-      })
-      .on('a[href]', {
-        element(element) {
-          const href = element.getAttribute('href');
-          element.setAttribute('href', href.replace('http://', 'https://'));
-        }
-      })
-      .transform(response);
-  }
-};
-```
-
-## WebSockets
-
-```typescript
-export default {
-  async fetch(request: Request): Promise<Response> {
-    const upgradeHeader = request.headers.get('Upgrade');
-    if (upgradeHeader !== 'websocket') {
-      return new Response('Expected WebSocket', { status: 426 });
-    }
-
-    const pair = new WebSocketPair();
-    const [client, server] = Object.values(pair);
-
-    server.accept();
-
-    server.addEventListener('message', (event) => {
-      server.send(`Echo: ${event.data}`);
-    });
-
-    return new Response(null, {
-      status: 101,
-      webSocket: client
-    });
-  }
-};
-```
-
-## Streams API
-
-```typescript
-const { readable, writable } = new TransformStream();
-
-const writer = writable.getWriter();
-writer.write(new TextEncoder().encode('chunk 1'));
-writer.write(new TextEncoder().encode('chunk 2'));
-writer.close();
-
-return new Response(readable, {
-  headers: { 'Content-Type': 'text/plain' }
-});
-```
-
-## Web Crypto API
-
-```typescript
-// Generate hash
-const data = new TextEncoder().encode('message');
-const hashBuffer = await crypto.subtle.digest('SHA-256', data);
-const hashArray = Array.from(new Uint8Array(hashBuffer));
-const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
-
-// HMAC signature
-const key = await crypto.subtle.importKey(
-  'raw',
-  new TextEncoder().encode('secret'),
-  { name: 'HMAC', hash: 'SHA-256' },
-  false,
-  ['sign', 'verify']
-);
-
-const signature = await crypto.subtle.sign('HMAC', key, data);
-const valid = await crypto.subtle.verify('HMAC', key, signature, data);
-
-// Random values
-const randomBytes = crypto.getRandomValues(new Uint8Array(32));
-const uuid = crypto.randomUUID();
-```
-
-## Encoding APIs
-
-```typescript
-// TextEncoder
-const encoder = new TextEncoder();
-const bytes = encoder.encode('Hello');
-
-// TextDecoder
-const decoder = new TextDecoder();
-const text = decoder.decode(bytes);
-
-// Base64
-const base64 = btoa('Hello');
-const decoded = atob(base64);
-```
-
-## URL API
-
-```typescript
-const url = new URL(request.url);
-const hostname = url.hostname;
-const pathname = url.pathname;
-const search = url.search;
-
-// Query parameters
-const name = url.searchParams.get('name');
-url.searchParams.set('page', '2');
-url.searchParams.delete('old');
-```
-
-## FormData API
-
-```typescript
-// Parse form data
-const formData = await request.formData();
-const name = formData.get('name');
-const file = formData.get('file');
-
-// Create form data
-const form = new FormData();
-form.append('name', 'value');
-form.append('file', blob, 'filename.txt');
-```
-
-## Response Types
-
-```typescript
-// Text
-return new Response('Hello');
-
-// JSON
-return Response.json({ message: 'Hello' });
-
-// Stream
-return new Response(readable);
-
-// Redirect
-return Response.redirect('https://example.com', 302);
-
-// Error
-return new Response('Not Found', { status: 404 });
-```
-
-## Request Cloning
-
-```typescript
-// Clone for multiple reads
-const clone = request.clone();
-const body1 = await request.json();
-const body2 = await clone.json();
-```
-
-## AbortController
-
-```typescript
-const controller = new AbortController();
-const { signal } = controller;
-
-setTimeout(() => controller.abort(), 5000);
-
-try {
-  const response = await fetch('https://slow-api.com', { signal });
-} catch (error) {
-  if (error.name === 'AbortError') {
-    console.log('Request timed out');
-  }
-}
-```
-
-## Scheduling APIs
-
-```typescript
-// setTimeout
-const timeoutId = setTimeout(() => {
-  console.log('Delayed');
-}, 1000);
-
-// setInterval
-const intervalId = setInterval(() => {
-  console.log('Repeated');
-}, 1000);
-
-// Clear
-clearTimeout(timeoutId);
-clearInterval(intervalId);
-```
-
-## Console API
-
-```typescript
-console.log('Info message');
-console.error('Error message');
-console.warn('Warning message');
-console.debug('Debug message');
-
-// Structured logging
-console.log(JSON.stringify({
-  level: 'info',
-  message: 'Request processed',
-  url: request.url,
-  timestamp: new Date().toISOString()
-}));
-```
-
-## Performance API
-
-```typescript
-const start = performance.now();
-await processRequest();
-const duration = performance.now() - start;
-console.log(`Processed in ${duration}ms`);
-```
-
-## Bindings Reference
-
-### KV Operations
-```typescript
-await env.KV.put(key, value, { expirationTtl: 3600, metadata: { userId: '123' } });
-const value = await env.KV.get(key, 'json');
-const { value, metadata } = await env.KV.getWithMetadata(key);
-await env.KV.delete(key);
-const list = await env.KV.list({ prefix: 'user:' });
-```
-
-### D1 Operations
-```typescript
-const result = await env.DB.prepare('SELECT * FROM users WHERE id = ?').bind(userId).first();
-const { results } = await env.DB.prepare('SELECT * FROM users').all();
-await env.DB.prepare('INSERT INTO users (name) VALUES (?)').bind(name).run();
-await env.DB.batch([stmt1, stmt2, stmt3]);
-```
-
-### R2 Operations
-```typescript
-await env.R2.put(key, value, { httpMetadata: { contentType: 'image/jpeg' } });
-const object = await env.R2.get(key);
-await env.R2.delete(key);
-const list = await env.R2.list({ prefix: 'uploads/' });
-const multipart = await env.R2.createMultipartUpload(key);
-```
-
-### Queue Operations
-```typescript
-await env.QUEUE.send({ type: 'email', to: 'user@example.com' });
-await env.QUEUE.sendBatch([{ body: msg1 }, { body: msg2 }]);
-```
-
-### Workers AI
-```typescript
-const response = await env.AI.run('@cf/meta/llama-3-8b-instruct', {
-  messages: [{ role: 'user', content: 'What is edge computing?' }]
-});
-```
-
-## Resources
-
-- Runtime APIs: https://developers.cloudflare.com/workers/runtime-apis/
-- Web Standards: https://developers.cloudflare.com/workers/runtime-apis/web-standards/
-- Bindings: https://developers.cloudflare.com/workers/runtime-apis/bindings/

package/.cursor/skills/devops/references/cloudflare-workers-basics.md

@@ -1,418 +0,0 @@
-# Cloudflare Workers Basics
-
-Getting started with Cloudflare Workers: serverless functions that run on edge network across 300+ cities.
-
-## Handler Types
-
-### Fetch Handler (HTTP Requests)
-```typescript
-export default {
-  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
-    return new Response('Hello World!');
-  }
-};
-```
-
-### Scheduled Handler (Cron Jobs)
-```typescript
-export default {
-  async scheduled(event: ScheduledEvent, env: Env, ctx: ExecutionContext): Promise<void> {
-    await fetch('https://api.example.com/cleanup');
-  }
-};
-```
-
-**Configure in wrangler.toml:**
-```toml
-[triggers]
-crons = ["0 0 * * *"]  # Daily at midnight
-```
-
-### Queue Handler (Message Processing)
-```typescript
-export default {
-  async queue(batch: MessageBatch, env: Env, ctx: ExecutionContext): Promise<void> {
-    for (const message of batch.messages) {
-      await processMessage(message.body);
-      message.ack();  // Acknowledge success
-    }
-  }
-};
-```
-
-### Email Handler (Email Routing)
-```typescript
-export default {
-  async email(message: ForwardableEmailMessage, env: Env, ctx: ExecutionContext): Promise<void> {
-    await message.forward('destination@example.com');
-  }
-};
-```
-
-## Request/Response Basics
-
-### Parsing Request
-```typescript
-const url = new URL(request.url);
-const method = request.method;
-const headers = request.headers;
-
-// Query parameters
-const name = url.searchParams.get('name');
-
-// JSON body
-const data = await request.json();
-
-// Text body
-const text = await request.text();
-
-// Form data
-const formData = await request.formData();
-```
-
-### Creating Response
-```typescript
-// Text response
-return new Response('Hello', { status: 200 });
-
-// JSON response
-return new Response(JSON.stringify({ message: 'Hello' }), {
-  status: 200,
-  headers: { 'Content-Type': 'application/json' }
-});
-
-// Stream response
-return new Response(readable, {
-  headers: { 'Content-Type': 'text/plain' }
-});
-
-// Redirect
-return Response.redirect('https://example.com', 302);
-```
-
-## Routing Patterns
-
-### URL-Based Routing
-```typescript
-export default {
-  async fetch(request: Request): Promise<Response> {
-    const url = new URL(request.url);
-
-    switch (url.pathname) {
-      case '/':
-        return new Response('Home');
-      case '/about':
-        return new Response('About');
-      default:
-        return new Response('Not Found', { status: 404 });
-    }
-  }
-};
-```
-
-### Using Hono Framework (Recommended)
-```typescript
-import { Hono } from 'hono';
-
-const app = new Hono();
-
-app.get('/', (c) => c.text('Home'));
-app.get('/api/users/:id', async (c) => {
-  const id = c.req.param('id');
-  const user = await getUser(id);
-  return c.json(user);
-});
-
-export default app;
-```
-
-## Working with Bindings
-
-### Environment Variables
-```toml
-# wrangler.toml
-[vars]
-API_URL = "https://api.example.com"
-```
-
-```typescript
-const apiUrl = env.API_URL;
-```
-
-### KV Namespace
-```typescript
-// Put with TTL
-await env.KV.put('session:token', JSON.stringify(data), {
-  expirationTtl: 3600
-});
-
-// Get
-const data = await env.KV.get('session:token', 'json');
-
-// Delete
-await env.KV.delete('session:token');
-
-// List with prefix
-const list = await env.KV.list({ prefix: 'user:123:' });
-```
-
-### D1 Database
-```typescript
-// Query
-const result = await env.DB.prepare(
-  'SELECT * FROM users WHERE id = ?'
-).bind(userId).first();
-
-// Insert
-await env.DB.prepare(
-  'INSERT INTO users (name, email) VALUES (?, ?)'
-).bind('Alice', 'alice@example.com').run();
-
-// Batch (atomic)
-await env.DB.batch([
-  env.DB.prepare('UPDATE accounts SET balance = balance - 100 WHERE id = ?').bind(1),
-  env.DB.prepare('UPDATE accounts SET balance = balance + 100 WHERE id = ?').bind(2)
-]);
-```
-
-### R2 Bucket
-```typescript
-// Put object
-await env.R2_BUCKET.put('path/to/file.jpg', fileBuffer, {
-  httpMetadata: {
-    contentType: 'image/jpeg'
-  }
-});
-
-// Get object
-const object = await env.R2_BUCKET.get('path/to/file.jpg');
-if (!object) {
-  return new Response('Not found', { status: 404 });
-}
-
-// Stream response
-return new Response(object.body, {
-  headers: {
-    'Content-Type': object.httpMetadata?.contentType || 'application/octet-stream'
-  }
-});
-
-// Delete
-await env.R2_BUCKET.delete('path/to/file.jpg');
-```
-
-## Context API
-
-### waitUntil (Background Tasks)
-```typescript
-export default {
-  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
-    // Run analytics after response sent
-    ctx.waitUntil(
-      fetch('https://analytics.example.com/log', {
-        method: 'POST',
-        body: JSON.stringify({ url: request.url })
-      })
-    );
-
-    return new Response('OK');
-  }
-};
-```
-
-### passThroughOnException
-```typescript
-// Continue to origin on error
-ctx.passThroughOnException();
-
-// Your code that might throw
-const data = await riskyOperation();
-```
-
-## Error Handling
-
-```typescript
-export default {
-  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
-    try {
-      const response = await processRequest(request, env);
-      return response;
-    } catch (error) {
-      console.error('Error:', error);
-
-      // Log to external service
-      ctx.waitUntil(
-        fetch('https://logging.example.com/error', {
-          method: 'POST',
-          body: JSON.stringify({
-            error: error.message,
-            url: request.url
-          })
-        })
-      );
-
-      return new Response('Internal Server Error', { status: 500 });
-    }
-  }
-};
-```
-
-## CORS
-
-```typescript
-function corsHeaders(origin: string) {
-  return {
-    'Access-Control-Allow-Origin': origin,
-    'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
-    'Access-Control-Allow-Headers': 'Content-Type, Authorization',
-    'Access-Control-Max-Age': '86400'
-  };
-}
-
-export default {
-  async fetch(request: Request): Promise<Response> {
-    const origin = request.headers.get('Origin') || '*';
-
-    // Handle preflight
-    if (request.method === 'OPTIONS') {
-      return new Response(null, { headers: corsHeaders(origin) });
-    }
-
-    // Handle request
-    const response = await handleRequest(request);
-    const headers = new Headers(response.headers);
-    Object.entries(corsHeaders(origin)).forEach(([key, value]) => {
-      headers.set(key, value);
-    });
-
-    return new Response(response.body, {
-      status: response.status,
-      headers
-    });
-  }
-};
-```
-
-## Cache API
-
-```typescript
-export default {
-  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
-    const cache = caches.default;
-    const cacheKey = new Request(request.url);
-
-    // Check cache
-    let response = await cache.match(cacheKey);
-    if (response) return response;
-
-    // Fetch from origin
-    response = await fetch(request);
-
-    // Cache response
-    ctx.waitUntil(cache.put(cacheKey, response.clone()));
-
-    return response;
-  }
-};
-```
-
-## Secrets Management
-
-```bash
-# Add secret
-wrangler secret put API_KEY
-# Enter value when prompted
-
-# Use in Worker
-const apiKey = env.API_KEY;
-```
-
-## Local Development
-
-```bash
-# Start local dev server
-wrangler dev
-
-# Test with remote edge
-wrangler dev --remote
-
-# Custom port
-wrangler dev --port 8080
-
-# Access at http://localhost:8787
-```
-
-## Deployment
-
-```bash
-# Deploy to production
-wrangler deploy
-
-# Deploy to specific environment
-wrangler deploy --env staging
-
-# Preview deployment
-wrangler deploy --dry-run
-```
-
-## Common Patterns
-
-### API Gateway
-```typescript
-import { Hono } from 'hono';
-
-const app = new Hono();
-
-app.get('/api/users', async (c) => {
-  const users = await c.env.DB.prepare('SELECT * FROM users').all();
-  return c.json(users.results);
-});
-
-app.post('/api/users', async (c) => {
-  const { name, email } = await c.req.json();
-  await c.env.DB.prepare(
-    'INSERT INTO users (name, email) VALUES (?, ?)'
-  ).bind(name, email).run();
-  return c.json({ success: true }, 201);
-});
-
-export default app;
-```
-
-### Rate Limiting
-```typescript
-async function rateLimit(ip: string, env: Env): Promise<boolean> {
-  const key = `ratelimit:${ip}`;
-  const limit = 100;
-  const window = 60;
-
-  const current = await env.KV.get(key);
-  const count = current ? parseInt(current) : 0;
-
-  if (count >= limit) return false;
-
-  await env.KV.put(key, (count + 1).toString(), {
-    expirationTtl: window
-  });
-
-  return true;
-}
-
-export default {
-  async fetch(request: Request, env: Env): Promise<Response> {
-    const ip = request.headers.get('CF-Connecting-IP') || 'unknown';
-
-    if (!await rateLimit(ip, env)) {
-      return new Response('Rate limit exceeded', { status: 429 });
-    }
-
-    return new Response('OK');
-  }
-};
-```
-
-## Resources
-
-- Docs: https://developers.cloudflare.com/workers/
-- Examples: https://developers.cloudflare.com/workers/examples/
-- Runtime APIs: https://developers.cloudflare.com/workers/runtime-apis/