cokit-cli 1.0.1 → 1.0.2

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

@@ -0,0 +1,418 @@
+# 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/

package/skills/ck-devops/references/docker-basics.md

@@ -0,0 +1,297 @@
+# Docker Basics
+
+Core concepts and workflows for Docker containerization.
+
+## Core Concepts
+
+**Containers:** Lightweight, isolated processes bundling apps with dependencies. Ephemeral by default.
+
+**Images:** Read-only blueprints for containers. Layered filesystem for reusability.
+
+**Volumes:** Persistent storage surviving container deletion.
+
+**Networks:** Enable container communication.
+
+## Dockerfile Best Practices
+
+### Essential Instructions
+```dockerfile
+FROM node:20-alpine              # Base image (use specific versions)
+WORKDIR /app                     # Working directory
+COPY package*.json ./            # Copy dependency files first
+RUN npm install --production     # Execute build commands
+COPY . .                         # Copy application code
+ENV NODE_ENV=production          # Environment variables
+EXPOSE 3000                      # Document exposed ports
+USER node                        # Run as non-root (security)
+CMD ["node", "server.js"]        # Default command
+```
+
+### Multi-Stage Builds (Production)
+```dockerfile
+# Stage 1: Build
+FROM node:20-alpine AS build
+WORKDIR /app
+COPY package*.json ./
+RUN npm install
+COPY . .
+RUN npm run build
+
+# Stage 2: Production
+FROM node:20-alpine AS production
+WORKDIR /app
+COPY --from=build /app/dist ./dist
+COPY --from=build /app/node_modules ./node_modules
+USER node
+EXPOSE 3000
+CMD ["node", "dist/server.js"]
+```
+
+Benefits: Smaller images, improved security, no build tools in production.
+
+### .dockerignore
+```
+node_modules
+.git
+.env
+*.log
+.DS_Store
+README.md
+docker-compose.yml
+dist
+coverage
+```
+
+## Building Images
+
+```bash
+# Build with tag
+docker build -t myapp:1.0 .
+
+# Build targeting specific stage
+docker build -t myapp:dev --target build .
+
+# Build for multiple platforms
+docker buildx build --platform linux/amd64,linux/arm64 -t myapp:1.0 .
+
+# View layers
+docker image history myapp:1.0
+```
+
+## Running Containers
+
+```bash
+# Basic run
+docker run myapp:1.0
+
+# Background (detached)
+docker run -d --name myapp myapp:1.0
+
+# Port mapping (host:container)
+docker run -p 8080:3000 myapp:1.0
+
+# Environment variables
+docker run -e NODE_ENV=production myapp:1.0
+
+# Volume mount (named volume)
+docker run -v mydata:/app/data myapp:1.0
+
+# Bind mount (development)
+docker run -v $(pwd)/src:/app/src myapp:1.0
+
+# Resource limits
+docker run --memory 512m --cpus 0.5 myapp:1.0
+
+# Interactive terminal
+docker run -it myapp:1.0 /bin/sh
+```
+
+## Container Management
+
+```bash
+# List containers
+docker ps
+docker ps -a
+
+# Logs
+docker logs myapp
+docker logs -f myapp          # Follow
+docker logs --tail 100 myapp  # Last 100 lines
+
+# Execute command
+docker exec myapp ls /app
+docker exec -it myapp /bin/sh  # Interactive shell
+
+# Stop/start
+docker stop myapp
+docker start myapp
+
+# Remove
+docker rm myapp
+docker rm -f myapp  # Force remove running
+
+# Inspect
+docker inspect myapp
+
+# Monitor resources
+docker stats myapp
+
+# Copy files
+docker cp myapp:/app/logs ./logs
+```
+
+## Volume Management
+
+```bash
+# Create volume
+docker volume create mydata
+
+# List volumes
+docker volume ls
+
+# Remove volume
+docker volume rm mydata
+
+# Remove unused volumes
+docker volume prune
+```
+
+## Network Management
+
+```bash
+# Create network
+docker network create my-network
+
+# List networks
+docker network ls
+
+# Connect container
+docker network connect my-network myapp
+
+# Disconnect
+docker network disconnect my-network myapp
+```
+
+## Language-Specific Dockerfiles
+
+### Node.js
+```dockerfile
+FROM node:20-alpine AS build
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --only=production
+COPY . .
+RUN npm run build
+
+FROM node:20-alpine
+WORKDIR /app
+COPY --from=build /app/dist ./dist
+COPY --from=build /app/node_modules ./node_modules
+USER node
+CMD ["node", "dist/server.js"]
+```
+
+### Python
+```dockerfile
+FROM python:3.11-slim AS build
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+FROM python:3.11-slim
+WORKDIR /app
+COPY --from=build /usr/local/lib/python3.11/site-packages /usr/local/lib/python3.11/site-packages
+COPY . .
+RUN adduser --disabled-password appuser
+USER appuser
+CMD ["python", "app.py"]
+```
+
+### Go
+```dockerfile
+FROM golang:1.21-alpine AS build
+WORKDIR /app
+COPY go.mod go.sum ./
+RUN go mod download
+COPY . .
+RUN CGO_ENABLED=0 go build -o main .
+
+FROM scratch
+COPY --from=build /app/main /main
+CMD ["/main"]
+```
+
+## Security Hardening
+
+```dockerfile
+# Use specific versions
+FROM node:20.11.0-alpine3.19
+
+# Create non-root user
+RUN addgroup -g 1001 -S nodejs && \
+    adduser -S nodejs -u 1001
+
+# Set ownership
+COPY --chown=nodejs:nodejs . .
+
+# Switch to non-root
+USER nodejs
+```
+
+## Troubleshooting
+
+### Container exits immediately
+```bash
+docker logs myapp
+docker run -it myapp /bin/sh
+docker run -it --entrypoint /bin/sh myapp
+```
+
+### Cannot connect
+```bash
+docker ps
+docker port myapp
+docker network inspect bridge
+docker inspect myapp | grep IPAddress
+```
+
+### Out of disk space
+```bash
+docker system df
+docker system prune -a
+docker volume prune
+```
+
+### Build cache issues
+```bash
+docker build --no-cache -t myapp .
+docker builder prune
+```
+
+## Best Practices
+
+- Use specific image versions, not `latest`
+- Run as non-root user
+- Multi-stage builds to minimize size
+- Implement health checks
+- Set resource limits
+- Keep images under 500MB
+- Scan for vulnerabilities: `docker scout cves myapp:1.0`
+
+## Quick Reference
+
+| Task | Command |
+|------|---------|
+| Build | `docker build -t myapp:1.0 .` |
+| Run | `docker run -d -p 8080:3000 myapp:1.0` |
+| Logs | `docker logs -f myapp` |
+| Shell | `docker exec -it myapp /bin/sh` |
+| Stop | `docker stop myapp` |
+| Remove | `docker rm myapp` |
+| Clean | `docker system prune -a` |
+
+## Resources
+
+- Docs: https://docs.docker.com
+- Best Practices: https://docs.docker.com/develop/dev-best-practices/
+- Dockerfile Reference: https://docs.docker.com/engine/reference/builder/