AI Skills

Give your AI coding agent deep knowledge about Temps. Skills are structured guides that teach AI assistants how to deploy, configure, and integrate with the platform — no copy-pasting docs required.

Overview

Temps ships with 10 skills that work with Claude Code, Cursor, Windsurf, Cline, and any agent that supports the skills protocol. Each skill is a curated set of instructions, code examples, and reference material that the AI loads when it recognises a relevant task.

For example, if you tell your AI agent "deploy my app to Temps" and the deploy-to-temps skill is installed, the agent already knows the exact CLI commands, framework detection logic, Dockerfile patterns, and troubleshooting steps — without you having to explain anything.

Installation

Skills are installed using the npx skills CLI. You can install all Temps skills at once or pick individual ones.

Install all skills

npx skills add gotempsh/temps

This launches an interactive selector:

Select skills to install (space to toggle)
  ◻ add-custom-domain
  ◻ add-error-tracking
  ◻ add-node-sdk
  ◻ add-react-analytics
  ◻ add-session-recording
  ◻ deploy-to-temps
  ◻ temps-cli
  ◻ temps-mcp-setup
  ◻ temps-platform-setup
  ◻ temps-plugin

Press space to toggle, then enter to install.

Install a specific skill

npx skills add gotempsh/temps --skill deploy-to-temps

Replace deploy-to-temps with any skill name from the table below.

Skills are installed into your project and become available to your AI agent automatically — no extra configuration needed.

Available Skills

Skill	Description	Triggers on
`deploy-to-temps`	Deploy apps with auto framework detection and CI/CD	"deploy to temps", "temps deployment"
`temps-cli`	Complete reference for all 56+ CLI commands	"temps cli", "temps command"
`temps-platform-setup`	Install and configure a self-hosted Temps instance	"install temps", "setup temps"
`temps-mcp-setup`	Configure the MCP server for AI agents	"temps mcp", "add temps to claude"
`add-react-analytics`	Add analytics, events, and Web Vitals to React apps	"add analytics", "track events"
`add-session-recording`	Add privacy-aware session recording with rrweb	"session recording", "session replay"
`add-node-sdk`	Integrate KV storage, blob storage, and server-side analytics	"temps node sdk", "temps kv"
`add-custom-domain`	Configure custom domains with automatic SSL/TLS	"custom domain", "ssl certificate"
`add-error-tracking`	Add Sentry-compatible error tracking to any framework	"error tracking", "sentry"
`temps-plugin`	Build external plugins for the Temps platform	"temps plugin", "build plugin"

deploy-to-temps

Deploy applications to Temps with automatic framework detection, Dockerfile generation, and container orchestration.

npx skills add gotempsh/temps --skill deploy-to-temps

Supported frameworks: Next.js, Vite, Create React App, Remix, Express, NestJS, Python/Flask, Python/Django, Go, Rust, and more.

Quick deploy via CLI

# Install and authenticate
npm install -g @temps-sdk/cli
bunx @temps-sdk/cli login

# Deploy current directory
bunx @temps-sdk/cli deploy

# Deploy with options
bunx @temps-sdk/cli deploy --project my-app --branch main

Build configuration

Create a temps.json in your project root for custom settings:

{
  "name": "my-app",
  "framework": "nextjs",
  "buildCommand": "npm run build",
  "installCommand": "npm ci",
  "outputDirectory": ".next",
  "nodeVersion": "20",
  "healthCheck": {
    "path": "/api/health",
    "interval": 30,
    "timeout": 10
  },
  "resources": {
    "cpu": "0.5",
    "memory": "512Mi",
    "replicas": { "min": 1, "max": 5 }
  }
}

Environment variables

bunx @temps-sdk/cli environments vars set DATABASE_URL="postgres://..."
bunx @temps-sdk/cli environments vars set --environments production  # import from file
bunx @temps-sdk/cli environments vars --project my-app

Rollbacks

bunx @temps-sdk/cli deployments list
# Roll back to a specific deployment
bunx @temps-sdk/cli rollback --project my-app --to <deployment-id>
# Roll back to previous deployment (omit --to)
bunx @temps-sdk/cli rollback --project my-app

temps-cli

Complete command-line reference covering all 56+ CLI commands — the most comprehensive skill at 2,000+ lines of documentation.

npx skills add gotempsh/temps --skill temps-cli

Installation

# Run without installing
bunx @temps-sdk/cli --version

# Install globally
npm install -g @temps-sdk/cli

Command groups

Group	What it covers
Deployments	Create, deploy, rollback, cancel, pause/resume, view logs
Managed Services	Provision PostgreSQL, Redis, MongoDB, S3 with auto-injected connection strings
Domains & TLS	Custom domains, wildcard certs, Cloudflare/Route53/DigitalOcean DNS
Monitoring	Uptime monitors, incidents, error tracking, audit logs, proxy logs
Notifications	Email providers (SES, Scaleway), DKIM, Slack/webhook alerts
Automation	`-y` flag, `--json` output, env-var auth

temps-platform-setup

Install, configure, and manage a self-hosted Temps instance from scratch.

npx skills add gotempsh/temps --skill temps-platform-setup

Installation methods

# Install script
curl -fsSL https://temps.sh/deploy.sh | bash

# Docker Compose
git clone https://github.com/gotempsh/temps.git && cd temps
docker-compose up -d

# From source (requires Rust 1.70+)
cargo build --release

Initial setup

temps setup \
  --database-url "postgresql://postgres:temps@localhost:16432/temps" \
  --admin-email "you@example.com" \
  --wildcard-domain "*.yourdomain.com" \
  --dns-provider "cloudflare" \
  --cloudflare-token "your-token"

Start the server

temps serve \
  --database-url "postgresql://..." \
  --address 0.0.0.0:80 \
  --tls-address 0.0.0.0:443 \
  --console-address 0.0.0.0:8081

Port	Purpose
80 / 443	HTTP/HTTPS proxy
8081	Admin console
3000	API (default)

temps-mcp-setup

Configure the Temps MCP server so AI assistants can manage your infrastructure through natural language.

npx skills add gotempsh/temps --skill temps-mcp-setup

Claude Desktop (macOS)

Edit ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "temps": {
      "command": "npx",
      "args": ["-y", "@temps-sdk/mcp"],
      "env": {
        "TEMPS_API_URL": "https://your-temps-instance.com",
        "TEMPS_API_KEY": "tk_your_api_key"
      }
    }
  }
}

Claude Code (VS Code)

Add to .vscode/settings.json:

{
  "claude.mcpServers": {
    "temps": {
      "command": "npx",
      "args": ["-y", "@temps-sdk/mcp"],
      "env": {
        "TEMPS_API_URL": "https://your-temps-instance.com",
        "TEMPS_API_KEY": "tk_your_api_key"
      }
    }
  }
}

Obtain your API key from the Temps dashboard under Settings → API Keys.

For a full reference covering all 158 MCP tools and setup for 7+ AI clients, see the MCP Server documentation.

add-react-analytics

Add analytics to React applications: page views, custom events, scroll depth, engagement, session recording, and Web Vitals.

npx skills add gotempsh/temps --skill add-react-analytics

Setup

npm install @temps-sdk/react-analytics

Wrap your app with TempsAnalyticsProvider:

import { TempsAnalyticsProvider } from '@temps-sdk/react-analytics'

export default function RootLayout({ children }) {
  return (
    <TempsAnalyticsProvider projectId={process.env.NEXT_PUBLIC_TEMPS_PROJECT_ID}>
      {children}
    </TempsAnalyticsProvider>
  )
}

Available hooks

Hook	Purpose
`useTrackEvent`	Track custom events with properties
`useAnalytics`	Access the analytics instance directly
`useScrollVisibility`	Track element scroll visibility
`usePageLeave`	Fire event when user leaves the page
`useEngagementTracking`	Heartbeat-based engagement tracking
`useSpeedAnalytics`	Capture Web Vitals (LCP, CLS, INP, etc.)
`useTrackPageview`	Manual pageview logging

Framework support: Next.js App Router, Next.js Pages Router, Vite, Create React App, Remix.

add-session-recording

Add privacy-aware session recording and replay using rrweb.

npx skills add gotempsh/temps --skill add-session-recording

Wrap your app with both providers:

import { TempsAnalyticsProvider, SessionRecordingProvider } from '@temps-sdk/react-analytics'

export default function App({ children }) {
  return (
    <TempsAnalyticsProvider projectId="...">
      <SessionRecordingProvider>
        {children}
      </SessionRecordingProvider>
    </TempsAnalyticsProvider>
  )
}

Privacy controls

<!-- Block entire element -->
<div data-rr-block>Payment form</div>

<!-- Mask text content (shows asterisks) -->
<span data-rr-mask>Sensitive info</span>

<!-- Block by CSS class -->
<input class="sensitive" />

Runtime control

import { useSessionRecording } from '@temps-sdk/react-analytics'

// Inside a component wrapped with SessionRecordingProvider:
function ConsentBanner() {
  const { isRecordingEnabled, enableRecording, disableRecording } = useSessionRecording()

  return isRecordingEnabled
    ? <button onClick={disableRecording}>Opt out of recording</button>
    : <button onClick={enableRecording}>Allow session recording</button>
}

// Standalone (no provider needed):
import { useSessionRecordingControl } from '@temps-sdk/react-analytics'

function RecordingToggle() {
  const { isEnabled, enable, disable } = useSessionRecordingControl()
  return <button onClick={isEnabled ? disable : enable}>Toggle recording</button>
}

CLI access

Browse and export recordings from the terminal:

# List recent sessions for a project
bunx @temps-sdk/cli session-replay list -p my-app

# Show session metadata
bunx @temps-sdk/cli session-replay show <visitor-id> <session-id>

# Download all events from a session as JSON
bunx @temps-sdk/cli session-replay events <visitor-id> <session-id> --output session.json

add-node-sdk

Integrate the Temps Node.js SDK for server-side analytics, KV storage, blob storage, and API access.

npx skills add gotempsh/temps --skill add-node-sdk

npm install @temps-sdk/node @temps-sdk/kv @temps-sdk/blob

Server-side analytics

import { Temps } from '@temps-sdk/node'

const temps = new Temps({
  apiKey: process.env.TEMPS_API_KEY,
  projectId: process.env.TEMPS_PROJECT_ID,
})

temps.track('purchase_completed', { amount: 99, currency: 'USD' })
temps.identify(userId, { plan: 'pro' })

KV storage

import { kv } from '@temps-sdk/kv'

await kv.set('key', { value: 'data' }, { ttl: 3600 })
const value = await kv.get('key')
await kv.list({ prefix: 'user:' })

Blob storage

import { blob } from '@temps-sdk/blob'

await blob.put('file.txt', buffer)
const url = await blob.getSignedUrl('file.txt', { expiresIn: 3600 })

add-custom-domain

Configure custom domains for Temps deployments with automatic SSL/TLS via Let's Encrypt.

npx skills add gotempsh/temps --skill add-custom-domain

Via CLI

# Subdomain (CNAME)
bunx @temps-sdk/cli cdom add --domain app.example.com --project-id <project-id>

# Apex domain (A record)
bunx @temps-sdk/cli cdom add --domain example.com --project-id <project-id>

# Wildcard (requires Cloudflare DNS-01)
bunx @temps-sdk/cli cdom add --domain "*.example.com" --project-id <project-id>

bunx @temps-sdk/cli cdom list --project-id <project-id>

DNS records

Type	For	Value
CNAME	`app.example.com`	`cname.temps.sh`
A	`example.com`	Temps server IP
CNAME	`*.example.com`	`cname.temps.sh` (DNS-01 required)

Certificates renew automatically 30 days before expiry.

add-error-tracking

Add Sentry-compatible error tracking to any framework. The Temps DSN is a drop-in replacement for a Sentry DSN — use the official Sentry SDK and point it at your Temps instance.

npx skills add gotempsh/temps --skill add-error-tracking

Next.js

npm install @sentry/nextjs

// sentry.client.config.ts
import * as Sentry from '@sentry/nextjs'

Sentry.init({
  dsn: process.env.NEXT_PUBLIC_SENTRY_DSN, // your Temps DSN
})

Environment variable by framework

Framework	Variable
Next.js	`NEXT_PUBLIC_SENTRY_DSN`
Vite / React / Vue	`VITE_SENTRY_DSN`
SvelteKit	`PUBLIC_SENTRY_DSN`
Node.js / Go / Others	`SENTRY_DSN`

Find your Temps DSN in the dashboard under Error Tracking → Project Settings.

temps-plugin

Build external plugins for the Temps platform as standalone Rust binaries. Plugins are discovered automatically, spawned by Temps, and communicate over Unix domain sockets.

npx skills add gotempsh/temps --skill temps-plugin

Temps proxies POST /api/x/{plugin_name}/* to your plugin's socket and serves the plugin UI at /api/x/{plugin_name}/ui/*.

Project structure

my-plugin/
├── Cargo.toml       # SDK dependency
├── build.rs         # Vite UI compilation
├── src/
│   ├── main.rs      # Plugin struct and routes
│   ├── db.rs        # SQLite via sea-orm
│   └── types.rs     # API DTOs
└── web/             # React + TypeScript UI

Key constraints

Never register a /health route — the SDK provides one automatically
Never use #[tokio::main] — the SDK creates its own runtime
Use tokio::task::block_in_place() for async in the router() function
Access Temps data via ctx.temps(), never directly via the database

Additional Resources

MCP Server Setup

Temps SDKs

CLI Getting Started

AI Skills

Install all skills

Install a specific skill

Quick deploy via CLI

Build configuration

Environment variables

Rollbacks

Installation

Command groups

Installation methods

Initial setup

Start the server

Claude Desktop (macOS)

Claude Code (VS Code)

Setup

Available hooks

Privacy controls

Runtime control

CLI access

Server-side analytics

KV storage

Blob storage

Via CLI

DNS records

Next.js

Environment variable by framework

Project structure

Key constraints

Ask anything