gkt-node 3.3.0

package/assets/.agent/skills/freshdesk-automation/SKILL.md

@@ -0,0 +1,219 @@
+---
+name: freshdesk-automation
+description: "Automate Freshdesk helpdesk operations including tickets, contacts, companies, notes, and replies via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Freshdesk Automation via Rube MCP
+
+Automate Freshdesk customer support workflows including ticket management, contact and company operations, notes, replies, and ticket search through Composio's Freshdesk toolkit.
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Freshdesk connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `freshdesk`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `freshdesk`
+3. If connection is not ACTIVE, follow the returned auth link to complete Freshdesk authentication
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Core Workflows
+
+### 1. Create and Manage Tickets
+
+**When to use**: User wants to create a new support ticket, update an existing ticket, or view ticket details.
+
+**Tool sequence**:
+1. `FRESHDESK_SEARCH_CONTACTS` - Find requester by email to get requester_id [Optional]
+2. `FRESHDESK_LIST_TICKET_FIELDS` - Check available custom fields and statuses [Optional]
+3. `FRESHDESK_CREATE_TICKET` - Create a new ticket with subject, description, requester info [Required]
+4. `FRESHDESK_UPDATE_TICKET` - Modify ticket status, priority, assignee, or other fields [Optional]
+5. `FRESHDESK_VIEW_TICKET` - Retrieve full ticket details by ID [Optional]
+
+**Key parameters for FRESHDESK_CREATE_TICKET**:
+- `subject`: Ticket subject (required)
+- `description`: HTML content of the ticket (required)
+- `email`: Requester email (at least one requester identifier required)
+- `requester_id`: User ID of requester (alternative to email)
+- `status`: 2=Open, 3=Pending, 4=Resolved, 5=Closed (default 2)
+- `priority`: 1=Low, 2=Medium, 3=High, 4=Urgent (default 1)
+- `source`: 1=Email, 2=Portal, 3=Phone, 7=Chat (default 2)
+- `responder_id`: Agent ID to assign the ticket to
+- `group_id`: Group to assign the ticket to
+- `tags`: Array of tag strings
+- `custom_fields`: Object with `cf_<field_name>` keys
+
+**Pitfalls**:
+- At least one requester identifier is required: `requester_id`, `email`, `phone`, `facebook_id`, `twitter_id`, or `unique_external_id`
+- If `phone` is provided without `email`, then `name` becomes mandatory
+- `description` supports HTML formatting
+- `attachments` field expects multipart/form-data format, not file paths or URLs
+- Custom field keys must be prefixed with `cf_` (e.g., `cf_reference_number`)
+- Status and priority are integers, not strings
+
+### 2. Search and Filter Tickets
+
+**When to use**: User wants to find tickets by status, priority, date range, agent, or custom fields.
+
+**Tool sequence**:
+1. `FRESHDESK_GET_TICKETS` - List tickets with simple filters (status, priority, agent) [Required]
+2. `FRESHDESK_GET_SEARCH` - Advanced ticket search with query syntax [Required]
+3. `FRESHDESK_VIEW_TICKET` - Get full details for specific tickets from results [Optional]
+4. `FRESHDESK_LIST_TICKET_FIELDS` - Check available fields for search queries [Optional]
+
+**Key parameters for FRESHDESK_GET_TICKETS**:
+- `status`: Filter by status integer (2=Open, 3=Pending, 4=Resolved, 5=Closed)
+- `priority`: Filter by priority integer (1-4)
+- `agent_id`: Filter by assigned agent
+- `requester_id`: Filter by requester
+- `email`: Filter by requester email
+- `created_since`: ISO 8601 timestamp
+- `page` / `per_page`: Pagination (default 30 per page)
+- `sort_by` / `sort_order`: Sort field and direction
+
+**Key parameters for FRESHDESK_GET_SEARCH**:
+- `query`: Query string like `"status:2 AND priority:3"` or `"(created_at:>'2024-01-01' AND tag:'urgent')"`
+- `page`: Page number (1-10, max 300 total results)
+
+**Pitfalls**:
+- `FRESHDESK_GET_SEARCH` query must be enclosed in double quotes
+- Query string limited to 512 characters
+- Maximum 10 pages (300 results) from search endpoints
+- Date fields in queries use UTC format YYYY-MM-DD
+- Use `null` keyword to find tickets with empty fields (e.g., `"agent_id:null"`)
+- `FRESHDESK_LIST_ALL_TICKETS` takes no parameters and returns all tickets (use GET_TICKETS for filtering)
+
+### 3. Reply to and Add Notes on Tickets
+
+**When to use**: User wants to send a reply to a customer, add internal notes, or view conversation history.
+
+**Tool sequence**:
+1. `FRESHDESK_VIEW_TICKET` - Verify ticket exists and check current state [Prerequisite]
+2. `FRESHDESK_REPLY_TO_TICKET` - Send a public reply to the requester [Required]
+3. `FRESHDESK_ADD_NOTE_TO_TICKET` - Add a private or public note [Required]
+4. `FRESHDESK_LIST_ALL_TICKET_CONVERSATIONS` - View all messages and notes on a ticket [Optional]
+5. `FRESHDESK_UPDATE_CONVERSATIONS` - Edit an existing note [Optional]
+
+**Key parameters for FRESHDESK_REPLY_TO_TICKET**:
+- `ticket_id`: Ticket ID (integer, required)
+- `body`: Reply content, supports HTML (required)
+- `cc_emails` / `bcc_emails`: Additional recipients (max 50 total across to/cc/bcc)
+- `from_email`: Override sender email if multiple support emails configured
+- `user_id`: Agent ID to reply on behalf of
+
+**Key parameters for FRESHDESK_ADD_NOTE_TO_TICKET**:
+- `ticket_id`: Ticket ID (integer, required)
+- `body`: Note content, supports HTML (required)
+- `private`: true for agent-only visibility, false for public (default true)
+- `notify_emails`: Only accepts agent email addresses, not external contacts
+
+**Pitfalls**:
+- There are two reply tools: `FRESHDESK_REPLY_TO_TICKET` (more features) and `FRESHDESK_REPLY_TICKET` (simpler); both work
+- `FRESHDESK_ADD_NOTE_TO_TICKET` defaults to private (agent-only); set `private: false` for public notes
+- `notify_emails` in notes only accepts agent emails, not customer emails
+- Only notes can be edited via `FRESHDESK_UPDATE_CONVERSATIONS`; incoming replies cannot be edited
+
+### 4. Manage Contacts and Companies
+
+**When to use**: User wants to create, search, or manage customer contacts and company records.
+
+**Tool sequence**:
+1. `FRESHDESK_SEARCH_CONTACTS` - Search contacts by email, phone, or company [Required]
+2. `FRESHDESK_GET_CONTACTS` - List contacts with filters [Optional]
+3. `FRESHDESK_IMPORT_CONTACT` - Bulk import contacts from CSV [Optional]
+4. `FRESHDESK_SEARCH_COMPANIES` - Search companies by custom fields [Required]
+5. `FRESHDESK_GET_COMPANIES` - List all companies [Optional]
+6. `FRESHDESK_CREATE_COMPANIES` - Create a new company [Optional]
+7. `FRESHDESK_UPDATE_COMPANIES` - Update company details [Optional]
+8. `FRESHDESK_LIST_COMPANY_FIELDS` - Check available company fields [Optional]
+
+**Key parameters for FRESHDESK_SEARCH_CONTACTS**:
+- `query`: Search string like `"email:'user@example.com'"` (required)
+- `page`: Pagination (1-10, max 30 per page)
+
+**Key parameters for FRESHDESK_CREATE_COMPANIES**:
+- `name`: Company name (required)
+- `domains`: Array of domain strings for auto-association with contacts
+- `health_score`: "Happy", "Doing okay", or "At risk"
+- `account_tier`: "Basic", "Premium", or "Enterprise"
+- `industry`: Standard industry classification
+
+**Pitfalls**:
+- `FRESHDESK_SEARCH_CONTACTS` requires exact matches; partial/regex searches are not supported
+- `FRESHDESK_SEARCH_COMPANIES` cannot search by standard `name` field; use custom fields or `created_at`
+- Company custom fields do NOT use the `cf_` prefix (unlike ticket custom fields)
+- `domains` on companies enables automatic contact-to-company association by email domain
+- Contact search queries require string values in single quotes inside double-quoted query
+
+## Common Patterns
+
+### ID Resolution
+Always resolve display values to IDs before operations:
+- **Requester email -> requester_id**: `FRESHDESK_SEARCH_CONTACTS` with `"email:'user@example.com'"`
+- **Company name -> company_id**: `FRESHDESK_GET_COMPANIES` and match by name (search by name not supported)
+- **Agent name -> agent_id**: Not directly available; use agent_id from ticket responses or admin configuration
+
+### Pagination
+Freshdesk uses page-based pagination:
+- `FRESHDESK_GET_TICKETS`: `page` (starting at 1) and `per_page` (max 100)
+- `FRESHDESK_GET_SEARCH`: `page` (1-10, 30 results per page, max 300 total)
+- `FRESHDESK_SEARCH_CONTACTS`: `page` (1-10, 30 per page)
+- `FRESHDESK_LIST_ALL_TICKET_CONVERSATIONS`: `page` and `per_page` (max 100)
+
+## Known Pitfalls
+
+### ID Formats
+- Ticket IDs, contact IDs, company IDs, agent IDs, and group IDs are all integers
+- There are no string-based IDs in Freshdesk
+
+### Rate Limits
+- Freshdesk enforces per-account API rate limits based on plan tier
+- Bulk operations should be paced to avoid 429 responses
+- Search endpoints are limited to 300 total results (10 pages of 30)
+
+### Parameter Quirks
+- Status values: 2=Open, 3=Pending, 4=Resolved, 5=Closed (integers, not strings)
+- Priority values: 1=Low, 2=Medium, 3=High, 4=Urgent (integers, not strings)
+- Source values: 1=Email, 2=Portal, 3=Phone, 7=Chat, 9=Feedback Widget, 10=Outbound Email
+- Ticket custom fields use `cf_` prefix; company custom fields do NOT
+- `description` in tickets supports HTML formatting
+- Search query strings must be in double quotes with string values in single quotes
+- `FRESHDESK_LIST_ALL_TICKETS` returns all tickets with no filter parameters
+
+### Response Structure
+- Ticket details include nested objects for requester, assignee, and conversation data
+- Search results are paginated with a maximum of 300 results across 10 pages
+- Conversation lists include both replies and notes in chronological order
+
+## Quick Reference
+
+| Task | Tool Slug | Key Params |
+|------|-----------|------------|
+| Create ticket | `FRESHDESK_CREATE_TICKET` | `subject`, `description`, `email`, `priority` |
+| Update ticket | `FRESHDESK_UPDATE_TICKET` | `ticket_id`, `status`, `priority` |
+| View ticket | `FRESHDESK_VIEW_TICKET` | `ticket_id` |
+| List tickets | `FRESHDESK_GET_TICKETS` | `status`, `priority`, `page`, `per_page` |
+| List all tickets | `FRESHDESK_LIST_ALL_TICKETS` | (none) |
+| Search tickets | `FRESHDESK_GET_SEARCH` | `query`, `page` |
+| Reply to ticket | `FRESHDESK_REPLY_TO_TICKET` | `ticket_id`, `body`, `cc_emails` |
+| Reply (simple) | `FRESHDESK_REPLY_TICKET` | `ticket_id`, `body` |
+| Add note | `FRESHDESK_ADD_NOTE_TO_TICKET` | `ticket_id`, `body`, `private` |
+| List conversations | `FRESHDESK_LIST_ALL_TICKET_CONVERSATIONS` | `ticket_id`, `page` |
+| Update note | `FRESHDESK_UPDATE_CONVERSATIONS` | `conversation_id`, `body` |
+| Search contacts | `FRESHDESK_SEARCH_CONTACTS` | `query`, `page` |
+| List contacts | `FRESHDESK_GET_CONTACTS` | `email`, `company_id`, `page` |
+| Import contacts | `FRESHDESK_IMPORT_CONTACT` | `file`, `name_column_index`, `email_column_index` |
+| Create company | `FRESHDESK_CREATE_COMPANIES` | `name`, `domains`, `industry` |
+| Update company | `FRESHDESK_UPDATE_COMPANIES` | `company_id`, `name`, `domains` |
+| Search companies | `FRESHDESK_SEARCH_COMPANIES` | `query`, `page` |
+| List companies | `FRESHDESK_GET_COMPANIES` | `page` |
+| List ticket fields | `FRESHDESK_LIST_TICKET_FIELDS` | (none) |
+| List company fields | `FRESHDESK_LIST_COMPANY_FIELDS` | (none) |

package/assets/.agent/skills/frontend-developer/SKILL.md

@@ -0,0 +1,171 @@
+---
+name: frontend-developer
+description: Build React components, implement responsive layouts, and handle
+  client-side state management. Masters React 19, Next.js 15, and modern
+  frontend architecture. Optimizes performance and ensures accessibility. Use
+  PROACTIVELY when creating UI components or fixing frontend issues.
+metadata:
+  model: inherit
+---
+You are a frontend development expert specializing in modern React applications, Next.js, and cutting-edge frontend architecture.
+
+## Use this skill when
+
+- Building React or Next.js UI components and pages
+- Fixing frontend performance, accessibility, or state issues
+- Designing client-side data fetching and interaction flows
+
+## Do not use this skill when
+
+- You only need backend API architecture
+- You are building native apps outside the web stack
+- You need pure visual design without implementation guidance
+
+## Instructions
+
+1. Clarify requirements, target devices, and performance goals.
+2. Choose component structure and state or data approach.
+3. Implement UI with accessibility and responsive behavior.
+4. Validate performance and UX with profiling and audits.
+
+## Purpose
+Expert frontend developer specializing in React 19+, Next.js 15+, and modern web application development. Masters both client-side and server-side rendering patterns, with deep knowledge of the React ecosystem including RSC, concurrent features, and advanced performance optimization.
+
+## Capabilities
+
+### Core React Expertise
+- React 19 features including Actions, Server Components, and async transitions
+- Concurrent rendering and Suspense patterns for optimal UX
+- Advanced hooks (useActionState, useOptimistic, useTransition, useDeferredValue)
+- Component architecture with performance optimization (React.memo, useMemo, useCallback)
+- Custom hooks and hook composition patterns
+- Error boundaries and error handling strategies
+- React DevTools profiling and optimization techniques
+
+### Next.js & Full-Stack Integration
+- Next.js 15 App Router with Server Components and Client Components
+- React Server Components (RSC) and streaming patterns
+- Server Actions for seamless client-server data mutations
+- Advanced routing with parallel routes, intercepting routes, and route handlers
+- Incremental Static Regeneration (ISR) and dynamic rendering
+- Edge runtime and middleware configuration
+- Image optimization and Core Web Vitals optimization
+- API routes and serverless function patterns
+
+### Modern Frontend Architecture
+- Component-driven development with atomic design principles
+- Micro-frontends architecture and module federation
+- Design system integration and component libraries
+- Build optimization with Webpack 5, Turbopack, and Vite
+- Bundle analysis and code splitting strategies
+- Progressive Web App (PWA) implementation
+- Service workers and offline-first patterns
+
+### State Management & Data Fetching
+- Modern state management with Zustand, Jotai, and Valtio
+- React Query/TanStack Query for server state management
+- SWR for data fetching and caching
+- Context API optimization and provider patterns
+- Redux Toolkit for complex state scenarios
+- Real-time data with WebSockets and Server-Sent Events
+- Optimistic updates and conflict resolution
+
+### Styling & Design Systems
+- Tailwind CSS with advanced configuration and plugins
+- CSS-in-JS with emotion, styled-components, and vanilla-extract
+- CSS Modules and PostCSS optimization
+- Design tokens and theming systems
+- Responsive design with container queries
+- CSS Grid and Flexbox mastery
+- Animation libraries (Framer Motion, React Spring)
+- Dark mode and theme switching patterns
+
+### Performance & Optimization
+- Core Web Vitals optimization (LCP, FID, CLS)
+- Advanced code splitting and dynamic imports
+- Image optimization and lazy loading strategies
+- Font optimization and variable fonts
+- Memory leak prevention and performance monitoring
+- Bundle analysis and tree shaking
+- Critical resource prioritization
+- Service worker caching strategies
+
+### Testing & Quality Assurance
+- React Testing Library for component testing
+- Jest configuration and advanced testing patterns
+- End-to-end testing with Playwright and Cypress
+- Visual regression testing with Storybook
+- Performance testing and lighthouse CI
+- Accessibility testing with axe-core
+- Type safety with TypeScript 5.x features
+
+### Accessibility & Inclusive Design
+- WCAG 2.1/2.2 AA compliance implementation
+- ARIA patterns and semantic HTML
+- Keyboard navigation and focus management
+- Screen reader optimization
+- Color contrast and visual accessibility
+- Accessible form patterns and validation
+- Inclusive design principles
+
+### Developer Experience & Tooling
+- Modern development workflows with hot reload
+- ESLint and Prettier configuration
+- Husky and lint-staged for git hooks
+- Storybook for component documentation
+- Chromatic for visual testing
+- GitHub Actions and CI/CD pipelines
+- Monorepo management with Nx, Turbo, or Lerna
+
+### Third-Party Integrations
+- Authentication with NextAuth.js, Auth0, and Clerk
+- Payment processing with Stripe and PayPal
+- Analytics integration (Google Analytics 4, Mixpanel)
+- CMS integration (Contentful, Sanity, Strapi)
+- Database integration with Prisma and Drizzle
+- Email services and notification systems
+- CDN and asset optimization
+
+## Behavioral Traits
+- Prioritizes user experience and performance equally
+- Writes maintainable, scalable component architectures
+- Implements comprehensive error handling and loading states
+- Uses TypeScript for type safety and better DX
+- Follows React and Next.js best practices religiously
+- Considers accessibility from the design phase
+- Implements proper SEO and meta tag management
+- Uses modern CSS features and responsive design patterns
+- Optimizes for Core Web Vitals and lighthouse scores
+- Documents components with clear props and usage examples
+
+## Knowledge Base
+- React 19+ documentation and experimental features
+- Next.js 15+ App Router patterns and best practices
+- TypeScript 5.x advanced features and patterns
+- Modern CSS specifications and browser APIs
+- Web Performance optimization techniques
+- Accessibility standards and testing methodologies
+- Modern build tools and bundler configurations
+- Progressive Web App standards and service workers
+- SEO best practices for modern SPAs and SSR
+- Browser APIs and polyfill strategies
+
+## Response Approach
+1. **Analyze requirements** for modern React/Next.js patterns
+2. **Suggest performance-optimized solutions** using React 19 features
+3. **Provide production-ready code** with proper TypeScript types
+4. **Include accessibility considerations** and ARIA patterns
+5. **Consider SEO and meta tag implications** for SSR/SSG
+6. **Implement proper error boundaries** and loading states
+7. **Optimize for Core Web Vitals** and user experience
+8. **Include Storybook stories** and component documentation
+
+## Example Interactions
+- "Build a server component that streams data with Suspense boundaries"
+- "Create a form with Server Actions and optimistic updates"
+- "Implement a design system component with Tailwind and TypeScript"
+- "Optimize this React component for better rendering performance"
+- "Set up Next.js middleware for authentication and routing"
+- "Create an accessible data table with sorting and filtering"
+- "Implement real-time updates with WebSockets and React Query"
+- "Build a PWA with offline capabilities and push notifications"

package/assets/.agent/skills/gcp-cloud-run/SKILL.md

@@ -0,0 +1,288 @@
+---
+name: gcp-cloud-run
+description: "Specialized skill for building production-ready serverless applications on GCP. Covers Cloud Run services (containerized), Cloud Run Functions (event-driven), cold start optimization, and event-driven architecture with Pub/Sub."
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# GCP Cloud Run
+
+## Patterns
+
+### Cloud Run Service Pattern
+
+Containerized web service on Cloud Run
+
+**When to use**: ['Web applications and APIs', 'Need any runtime or library', 'Complex services with multiple endpoints', 'Stateless containerized workloads']
+
+```javascript
+```dockerfile
+# Dockerfile - Multi-stage build for smaller image
+FROM node:20-slim AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --only=production
+
+FROM node:20-slim
+WORKDIR /app
+
+# Copy only production dependencies
+COPY --from=builder /app/node_modules ./node_modules
+COPY src ./src
+COPY package.json ./
+
+# Cloud Run uses PORT env variable
+ENV PORT=8080
+EXPOSE 8080
+
+# Run as non-root user
+USER node
+
+CMD ["node", "src/index.js"]
+```
+
+```javascript
+// src/index.js
+const express = require('express');
+const app = express();
+
+app.use(express.json());
+
+// Health check endpoint
+app.get('/health', (req, res) => {
+  res.status(200).send('OK');
+});
+
+// API routes
+app.get('/api/items/:id', async (req, res) => {
+  try {
+    const item = await getItem(req.params.id);
+    res.json(item);
+  } catch (error) {
+    console.error('Error:', error);
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+// Graceful shutdown
+process.on('SIGTERM', () => {
+  console.log('SIGTERM received, shutting down gracefully');
+  server.close(() => {
+    console.log('Server closed');
+    process.exit(0);
+  });
+});
+
+const PORT = process.env.PORT || 8080;
+const server = app.listen(PORT, () => {
+  console.log(`Server listening on port ${PORT}`);
+});
+```
+
+```yaml
+# cloudbuild.yaml
+steps:
+  # Build the container image
+  - name: 'gcr.io/cloud-builders/docker'
+    args: ['build', '-t', 'gcr.io/$PROJECT_ID/my-service:$COMMIT_SHA', '.']
+
+  # Push the container image
+  - name: 'gcr.io/cloud-builders/docker'
+    args: ['push', 'gcr.io/$PROJECT_ID/my-service:$COMMIT_SHA']
+
+  # Deploy to Cloud Run
+  - name: 'gcr.io/google.com/cloudsdktool/cloud-sdk'
+    entrypoint: gcloud
+    args:
+      - 'run'
+      - 'deploy'
+      - 'my-service'
+      - '--image=gcr.io/$PROJECT_ID/my-service:$COMMIT_SHA'
+      - '--region=us-central1'
+      - '--platform=managed'
+      - '--allow-unauthenticated'
+      - '--memory=512Mi'
+      - '--cpu=1'
+      - '--min-instances=1'
+      - '--max-instances=100'
+     
+```
+
+### Cloud Run Functions Pattern
+
+Event-driven functions (formerly Cloud Functions)
+
+**When to use**: ['Simple event handlers', 'Pub/Sub message processing', 'Cloud Storage triggers', 'HTTP webhooks']
+
+```javascript
+```javascript
+// HTTP Function
+// index.js
+const functions = require('@google-cloud/functions-framework');
+
+functions.http('helloHttp', (req, res) => {
+  const name = req.query.name || req.body.name || 'World';
+  res.send(`Hello, ${name}!`);
+});
+```
+
+```javascript
+// Pub/Sub Function
+const functions = require('@google-cloud/functions-framework');
+
+functions.cloudEvent('processPubSub', (cloudEvent) => {
+  // Decode Pub/Sub message
+  const message = cloudEvent.data.message;
+  const data = message.data
+    ? JSON.parse(Buffer.from(message.data, 'base64').toString())
+    : {};
+
+  console.log('Received message:', data);
+
+  // Process message
+  processMessage(data);
+});
+```
+
+```javascript
+// Cloud Storage Function
+const functions = require('@google-cloud/functions-framework');
+
+functions.cloudEvent('processStorageEvent', async (cloudEvent) => {
+  const file = cloudEvent.data;
+
+  console.log(`Event: ${cloudEvent.type}`);
+  console.log(`Bucket: ${file.bucket}`);
+  console.log(`File: ${file.name}`);
+
+  if (cloudEvent.type === 'google.cloud.storage.object.v1.finalized') {
+    await processUploadedFile(file.bucket, file.name);
+  }
+});
+```
+
+```bash
+# Deploy HTTP function
+gcloud functions deploy hello-http \
+  --gen2 \
+  --runtime nodejs20 \
+  --trigger-http \
+  --allow-unauthenticated \
+  --region us-central1
+
+# Deploy Pub/Sub function
+gcloud functions deploy process-messages \
+  --gen2 \
+  --runtime nodejs20 \
+  --trigger-topic my-topic \
+  --region us-central1
+
+# Deploy Cloud Storage function
+gcloud functions deploy process-uploads \
+  --gen2 \
+  --runtime nodejs20 \
+  --trigger-event-filters="type=google.cloud.storage.object.v1.finalized" \
+  --trigger-event-filters="bucket=my-bucket" \
+  --region us-central1
+```
+```
+
+### Cold Start Optimization Pattern
+
+Minimize cold start latency for Cloud Run
+
+**When to use**: ['Latency-sensitive applications', 'User-facing APIs', 'High-traffic services']
+
+```javascript
+## 1. Enable Startup CPU Boost
+
+```bash
+gcloud run deploy my-service \
+  --cpu-boost \
+  --region us-central1
+```
+
+## 2. Set Minimum Instances
+
+```bash
+gcloud run deploy my-service \
+  --min-instances 1 \
+  --region us-central1
+```
+
+## 3. Optimize Container Image
+
+```dockerfile
+# Use distroless for minimal image
+FROM node:20-slim AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --only=production
+
+FROM gcr.io/distroless/nodejs20-debian12
+WORKDIR /app
+COPY --from=builder /app/node_modules ./node_modules
+COPY src ./src
+CMD ["src/index.js"]
+```
+
+## 4. Lazy Initialize Heavy Dependencies
+
+```javascript
+// Lazy load heavy libraries
+let bigQueryClient = null;
+
+function getBigQueryClient() {
+  if (!bigQueryClient) {
+    const { BigQuery } = require('@google-cloud/bigquery');
+    bigQueryClient = new BigQuery();
+  }
+  return bigQueryClient;
+}
+
+// Only initialize when needed
+app.get('/api/analytics', async (req, res) => {
+  const client = getBigQueryClient();
+  const results = await client.query({...});
+  res.json(results);
+});
+```
+
+## 5. Increase Memory (More CPU)
+
+```bash
+# Higher memory = more CPU during startup
+gcloud run deploy my-service \
+  --memory 1Gi \
+  --cpu 2 \
+  --region us-central1
+```
+```
+
+## Anti-Patterns
+
+### ❌ CPU-Intensive Work Without Concurrency=1
+
+**Why bad**: CPU is shared across concurrent requests. CPU-bound work
+will starve other requests, causing timeouts.
+
+### ❌ Writing Large Files to /tmp
+
+**Why bad**: /tmp is an in-memory filesystem. Large files consume
+your memory allocation and can cause OOM errors.
+
+### ❌ Long-Running Background Tasks
+
+**Why bad**: Cloud Run throttles CPU to near-zero when not handling
+requests. Background tasks will be extremely slow or stall.
+
+## ⚠️ Sharp Edges
+
+| Issue | Severity | Solution |
+|-------|----------|----------|
+| Issue | high | ## Calculate memory including /tmp usage |
+| Issue | high | ## Set appropriate concurrency |
+| Issue | high | ## Enable CPU always allocated |
+| Issue | medium | ## Configure connection pool with keep-alive |
+| Issue | high | ## Enable startup CPU boost |
+| Issue | medium | ## Explicitly set execution environment |
+| Issue | medium | ## Set consistent timeouts |