Vibekit

https://github.com/superagent-ai/vibekit
Admin
VibeKit is a safety layer for coding agents, providing an isolated sandbox with sensitive data...
Tokens:123,489
Snippets:520
Trust Score:8.3
License:MIT
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install and Start VibeKit Proxy

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/proxy/quickstart.mdx

Installs the VibeKit Proxy globally and starts the proxy server. Supports Node.js and Rust environments.

```bash
npm install -g vibekit-proxy
vibekit-proxy start
```

```rust
cargo install vibekit-proxy
vibekit-proxy start
```

--------------------------------

### Development Setup

Source: https://github.com/superagent-ai/vibekit/blob/main/packages/dashboard/README.md

Installs dependencies and starts the development server for the Vibekit dashboard.

```bash
npm install
npm run dev
```

--------------------------------

### Test VibeKit Proxy Setup

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/proxy/quickstart.mdx

Provides examples for testing the VibeKit Proxy setup using `curl` for Anthropic and OpenAI, and a JavaScript example for making a chat completion request.

```bash
curl -X POST http://localhost:8080/messages \
  -H "Content-Type: application/json" \
  -H "x-api-key: your-api-key" \
  -d '{
    "model": "claude-4-sonnet",
    "messages": [
      {
        "role": "user",
        "content": "Hello! Can you help me with a quick test?"
      }
    ]
  }'
```

```bash
curl -X POST http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer your-api-key" \
  -d '{
    "model": "gpt-5",
    "messages": [
      {
        "role": "user",
        "content": "Hello! Can you help me with a quick test?"
      }
    ]
  }'
```

```javascript
const response = await client.chat.completions.create({
  model: "gpt-5", // Use configured model
  messages: [
    { role: "user", content: "My SSN is 123-45-6789. What can you tell me about privacy?" }
  ],
});

console.log(response.choices[0].message.content);
// The SSN will be automatically redacted in both the request and response
```

--------------------------------

### Local Development Setup for Vibekit Dagger Package

Source: https://github.com/superagent-ai/vibekit/blob/main/packages/dagger/README.md

Guides users through setting up the Vibekit project locally for development, including cloning the repository, installing dependencies, building the dagger package, and running tests.

```bash
# Clone the repository
git clone https://github.com/vibekit/vibekit.git
cd vibekit

# Install dependencies
npm install

# Build the dagger package
cd packages/dagger
npm run build

# Run tests
npm test
```

--------------------------------

### Troubleshooting Docker Not Running

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/cli/installation.mdx

Guides users on how to check Docker status and start the Docker daemon if it's not running, which is necessary for the Docker sandbox feature.

```bash
# Check if Docker is installed
docker --version

# Check if Docker daemon is running
docker ps

# Start Docker
# macOS: Open Docker Desktop application
# Linux: sudo systemctl start docker
# Windows: Start Docker Desktop
```

--------------------------------

### VibeKit Quick Setup Examples

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/supported-sandboxes/dagger.mdx

Demonstrates various ways to initialize VibeKit with the Dagger provider, including interactive setup, Docker Hub optimization, GitHub Container Registry, and AWS ECR.

```bash
# Interactive setup with agent selection
vibekit init --providers dagger --agents claude,codex

# With Docker Hub image optimization (default)
docker login
vibekit init --providers dagger --agents claude,codex --upload-images

# With GitHub Container Registry
vibekit init --providers dagger --agents claude,codex \
  --registry ghcr --registry-user github-username --upload-images

# With AWS ECR
vibekit init --providers dagger --agents claude,codex \
  --registry ecr --registry-user $AWS_ACCOUNT_ID --upload-images
```

--------------------------------

### Install VibeKit SDK

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/sdk/quickstart.mdx

Installs the VibeKit Typescript SDK using either npm or yarn.

```bash
npm i @vibe-kit/sdk
```

```bash
yarn add @vibe-kit/sdk
```

--------------------------------

### Quick Start Example

Source: https://github.com/superagent-ai/vibekit/blob/main/packages/sdk/README.md

A basic example demonstrating how to configure and use the VibeKit SDK to generate code with an AI agent and an E2B sandbox.

```typescript
import { VibeKit } from "@vibe-kit/sdk";
import { createE2BProvider } from "@vibe-kit/e2b";

// Configure sandbox provider
const e2bProvider = createE2BProvider({
  apiKey: process.env.E2B_API_KEY!,
  templateId: "vibekit-claude",
});

// Create and configure VibeKit instance
const vibeKit = new VibeKit()
  .withAgent({
    type: "claude",
    provider: "anthropic",
    apiKey: process.env.ANTHROPIC_API_KEY!,
    model: "claude-sonnet-4-20250514",
  })
  .withSandbox(e2bProvider);

// Add event listeners
vibeKit.on("update", (update) => {
  console.log("Update:", update);
});

vibeKit.on("error", (error) => {
  console.error("Error:", error);
});

// Generate code
const result = await vibeKit.generateCode({
  prompt: "Create a simple web app that displays a list of users",
  mode: "code",
});

// Clean up when done
await vibeKit.kill();

console.log("Result:", result);
```

--------------------------------

### Direct Installation and Start

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/proxy/deployment.mdx

Instructions for installing and running the VibeKit proxy locally using npm for Node.js and cargo for Rust.

```bash
# Install and run locally (Node.js)
npm install -g vibekit-proxy
vibekit-proxy start --port 8080

# Install and run locally (Rust)
cargo install vibekit-proxy
vibekit-proxy start --port 8080
```

--------------------------------

### Development Setup

Source: https://github.com/superagent-ai/vibekit/blob/main/packages/cli/README.md

Steps to clone the Vibekit repository, install dependencies, and link the CLI for local development.

```bash
git clone <repo>
cd vibekit-cli
npm install
npm link
```

--------------------------------

### Configure VibeKit Proxy with Custom Path

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/proxy/quickstart.mdx

Starts the VibeKit Proxy and specifies a custom configuration file path. Applicable to both Node.js and Rust installations.

```bash
npm start -- --config=/etc/vibekit/vibekit.yaml
```

```rust
./target/release/vibekit-proxy start --config=/etc/vibekit/vibekit.yaml
```

--------------------------------

### VibeKit CLI Setup and Configuration

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/cli/quick-reference.mdx

Commands for installing the VibeKit CLI globally and configuring its settings. Optionally, set up global aliases for easier command execution.

```bash
npm install -g vibekit
vibekit
vibekit setup-aliases
```

--------------------------------

### VibeKit Proxy Configuration File

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/proxy/quickstart.mdx

Example of a `vibekit.yaml` file used to configure AI models and API endpoints for the VibeKit Proxy.

```yaml
models:
  - model_name: "gpt-5"
    provider: "openai"
    api_base: "https://api.openai.com"
  
  - model_name: "claude-4-sonnet"
    provider: "anthropic"
    api_base: "https://api.anthropic.com"
```

--------------------------------

### VibeKit Proxy Configuration Options

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/proxy/quickstart.mdx

Demonstrates how to start, check status, and stop the VibeKit Proxy with custom ports or in daemon mode.

```bash
# Start with custom port
npx @vibe-kit/proxy start --port 3000

# Run in background (daemon mode)
npx @vibe-kit/proxy start --daemon

# Check status on specific port
npx @vibe-kit/proxy status --port 3000

# Stop proxy on specific port
npx @vibe-kit/proxy stop --port 3000
```

--------------------------------

### Global CLI Installation

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/cli/installation.mdx

Installs the VibeKit CLI globally, making the 'vibekit' command available system-wide. Supports npm, yarn, and pnpm package managers.

```bash
npm install -g vibekit
```

```bash
yarn global add vibekit
```

```bash
pnpm add -g vibekit
```

--------------------------------

### Verifying VibeKit CLI Installation

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/cli/installation.mdx

Commands to check if the VibeKit CLI has been installed correctly and to view its version or help information.

```bash
# Check version
vibekit --version

# View help
vibekit --help
```

--------------------------------

### Installation

Source: https://github.com/superagent-ai/vibekit/blob/main/packages/sdk/README.md

Install the VibeKit SDK using npm.

```bash
npm install @vibe-kit/sdk
```

--------------------------------

### Install and Start LiteLLM Proxy

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/proxy/litellm.mdx

Installs LiteLLM with proxy support and starts the LiteLLM proxy server on port 4000. This is a prerequisite for integrating VibeKit Proxy with LiteLLM.

```bash
pip install litellm[proxy]

litellm --port 4000
```

--------------------------------

### Project-Specific CLI Installation

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/cli/installation.mdx

Installs the VibeKit CLI as a development dependency within a specific project. Supports npm, yarn, and pnpm.

```bash
npm install --save-dev vibekit
```

```bash
yarn add --dev vibekit
```

```bash
pnpm add -D vibekit
```

--------------------------------

### Start Dashboard Server Directly

Source: https://github.com/superagent-ai/vibekit/blob/main/packages/dashboard/README.md

Starts the Vibekit dashboard server programmatically using JavaScript. Requires the dashboard package to be installed.

```javascript
const DashboardServer = require('@vibe-kit/dashboard');

const server = new DashboardServer({
  port: 3001,
  hostname: 'localhost'
});

await server.start();
```

--------------------------------

### Basic Browser Authentication Setup

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/auth/browser.mdx

Demonstrates the initial setup for browser-based authentication using ClaudeWebAuth and LocalStorageTokenStorage. This involves importing the necessary classes and instantiating the authentication and storage objects.

```typescript
import { ClaudeWebAuth, LocalStorageTokenStorage } from '@vibe-kit/auth/browser';
// OR use the default import which is browser-safe:
// import { ClaudeAuth, LocalStorageTokenStorage } from '@vibe-kit/auth';

// Create storage
const storage = new LocalStorageTokenStorage();
const auth = new ClaudeWebAuth(storage);
```

--------------------------------

### Manual Dagger Installation

Source: https://github.com/superagent-ai/vibekit/blob/main/packages/dagger/README.md

Provides commands for manually installing Docker and Dagger, including verification steps. This is useful if automatic dependency installation fails.

```bash
# Install Docker (platform-specific)
# See: https://docs.docker.com/get-docker/

# Install Dagger
curl -fsSL https://dagger.io/install.sh | bash

# Verify installation
dagger version
```

--------------------------------

### Installation and Linking

Source: https://github.com/superagent-ai/vibekit/blob/main/packages/cli/README.md

Installs Vibekit CLI globally using npm or locally for development.

```bash
npm install -g vibekit-cli
```

```bash
npm install
npm link
```

--------------------------------

### Install and Verify Dagger CLI

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/supported-sandboxes/dagger.mdx

Installs the Dagger CLI by downloading and executing an installation script, then verifies the installation by checking the version. This is necessary for using Dagger functionalities.

```bash
curl -fsSL https://dl.dagger.io/install.sh | bash
dagger version
```

--------------------------------

### Running VibeKit CLI without Installation

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/cli/installation.mdx

Executes VibeKit commands directly using npx without requiring a prior installation. Useful for trying out commands or running specific agent tasks.

```bash
npx vibekit claude "Generate a REST API"
npx vibekit dashboard
```

--------------------------------

### Troubleshooting Permission Errors

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/cli/installation.mdx

Offers solutions for permission errors during global installation, recommending Node version managers or changing npm's default directory.

```bash
# Option 1: Use a Node version manager (recommended)
# Install nvm: https://github.com/nvm-sh/nvm
nvm install node
npm install -g vibekit

# Option 2: Change npm's default directory
mkdir ~/.npm-global
npm config set prefix '~/.npm-global'
export PATH=~/.npm-global/bin:$PATH
npm install -g vibekit
```

--------------------------------

### Troubleshooting 'Command Not Found'

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/cli/installation.mdx

Provides solutions for when the 'vibekit' command is not recognized after global installation, typically due to PATH configuration issues.

```bash
# Check npm global bin directory
npm config get prefix

# Add to PATH (example for macOS/Linux)
export PATH="$(npm config get prefix)/bin:$PATH"

# Make permanent by adding to ~/.bashrc or ~/.zshrc
echo 'export PATH="$(npm config get prefix)/bin:$PATH"' >> ~/.bashrc
```

```bash
# Check yarn global bin directory
yarn global bin

# Add to PATH
export PATH="$(yarn global bin):$PATH"
```

--------------------------------

### Install Mintlify CLI

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/README.md

Installs the Mintlify CLI globally, which is required for previewing documentation changes locally.

```bash
npm i -g mintlify
```

--------------------------------

### Install VibeKit and Sandbox Providers

Source: https://github.com/superagent-ai/vibekit/blob/main/LLM.md

Installs the core VibeKit package and optional sandbox provider packages using npm.

```bash
# Core VibeKit package
npm install @vibe-kit/vibekit

# Sandbox providers (choose one or more)
npm install @vibe-kit/e2b        # E2B sandbox provider
npm install @vibe-kit/daytona    # Daytona sandbox provider  
npm install @vibe-kit/northflank # Northflank sandbox provider
npm install @vibe-kit/cloudflare # Cloudflare sandbox provider (Workers only)
```

--------------------------------

### Updating VibeKit CLI

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/cli/installation.mdx

Instructions for updating the VibeKit CLI to the latest version using npm, yarn, or npx.

```bash
npm update -g vibekit
```

```bash
yarn global upgrade vibekit
```

```bash
# npx always uses the latest version
npx vibekit@latest
```

--------------------------------

### Install and Run Inngest CLI

Source: https://github.com/superagent-ai/vibekit/blob/main/templates/codex-clone/README.md

Installs the Inngest CLI globally or via npx, which is essential for running background functions locally. It also shows how to start the Inngest development server.

```bash
# Install globally
npm install -g inngest

# Or using npx (recommended)
npx inngest-cli@latest

# Start the Inngest Dev Server
npx inngest-cli@latest dev
```

--------------------------------

### Install Dependencies

Source: https://github.com/superagent-ai/vibekit/blob/main/templates/v0-clone/README.md

Installs project dependencies using npm. Ensure Node.js (v18+) is installed.

```bash
npm install
```

--------------------------------

### VibeKit Proxy Installation and Usage

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/cli/proxy-server.mdx

Instructions for installing and running the VibeKit proxy, either directly with npx or globally via npm, and using it with the VibeKit CLI.

```bash
# Direct usage (no installation)
npx vibekit-proxy start

# Global installation
npm install -g vibekit-proxy
vibekit-proxy start

# Through VibeKit CLI
vibekit proxy start --port 8080
```

--------------------------------

### Install @vibe-kit/auth

Source: https://github.com/superagent-ai/vibekit/blob/main/packages/auth/README.md

Installs the @vibe-kit/auth package using npm.

```bash
npm install @vibe-kit/auth
```

--------------------------------

### Install Dagger CLI (Linux)

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/supported-sandboxes/dagger.mdx

Installs the Dagger command-line interface on Linux by downloading and executing an installation script.

```bash
curl -fsSL https://dl.dagger.io/dagger/install.sh | BIN_DIR=$HOME/.local/bin sh
```

--------------------------------

### VibeKit Cloudflare Worker Deployment and Development Commands

Source: https://github.com/superagent-ai/vibekit/blob/main/LLM.md

Provides essential commands for setting up and deploying a VibeKit-based Cloudflare Worker. Includes installing dependencies, deploying to Cloudflare, and starting the local development server.

```bash
# Install dependencies
npm install @vibe-kit/vibekit @vibe-kit/cloudflare

# Deploy to Cloudflare
wrangler deploy

# For local development
wrangler dev
```

--------------------------------

### Install Vibekit Dashboard

Source: https://github.com/superagent-ai/vibekit/blob/main/packages/dashboard/README.md

Installs the @vibe-kit/dashboard package using npm.

```bash
npm install @vibe-kit/dashboard
```

--------------------------------

### Start Next.js Development Server

Source: https://github.com/superagent-ai/vibekit/blob/main/templates/v0-clone/README.md

Starts the Next.js development server, making the application accessible at http://localhost:3000. This command should be run in a separate terminal from the Inngest server.

```bash
npm run dev
```

--------------------------------

### Startup Script for VibeKit Proxy Installation

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/proxy/gcp-deployment.mdx

A bash script to install Node.js, the VibeKit proxy globally, and configure a systemd service to run the proxy. It includes security best practices.

```bash
#!/bin/bash

# Update system
apt-get update
apt-get install -y curl software-properties-common

# Install Node.js 18
curl -fsSL https://deb.nodesource.com/setup_18.x | bash -
apt-get install -y nodejs

# Install VibeKit Proxy
npm install -g @vibe-kit/proxy

# Create systemd service
cat > /etc/systemd/system/vibekit-proxy.service << EOF
[Unit]
Description=VibeKit Proxy Service
After=network.target

[Service]
Type=simple
User=www-data
Group=www-data
WorkingDirectory=/var/www
ExecStart=/usr/bin/npx @vibe-kit/proxy start --port 8080
Restart=always
RestartSec=10
Environment=NODE_ENV=production
Environment=PORT=8080

# Security settings
NoNewPrivileges=true
ProtectSystem=strict
ProtectHome=true
ReadWritePaths=/var/www

[Install]
WantedBy=multi-user.target
EOF

# Create working directory
mkdir -p /var/www
chown www-data:www-data /var/www

# Enable and start service
systemctl daemon-reload
systemctl enable vibekit-proxy
systemctl start vibekit-proxy

```

--------------------------------

### Install Dagger CLI (Windows)

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/supported-sandboxes/dagger.mdx

Installs the Dagger command-line interface on Windows using the Windows Package Manager (winget).

```bash
winget install Dagger.Cli
```

--------------------------------

### Start Docker Service (Linux)

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/supported-sandboxes/dagger.mdx

Starts the Docker service using systemctl. This is a prerequisite for running Docker containers.

```bash
sudo systemctl start docker
```

--------------------------------

### Install and Run Inngest CLI

Source: https://github.com/superagent-ai/vibekit/blob/main/templates/v0-clone/README.md

Installs the Inngest CLI globally or via npx, and then runs the Inngest development server. The CLI is required for local development of background functions.

```bash
# Install globally
npm install -g inngest

# Or using npx (recommended)
npx inngest-cli@latest
```

```bash
npx inngest-cli@latest dev
```

--------------------------------

### Install @vibe-kit/daytona

Source: https://github.com/superagent-ai/vibekit/blob/main/packages/daytona/README.md

Installs the Daytona provider package for VibeKit using npm.

```bash
npm install @vibe-kit/daytona
```

--------------------------------

### Install E2B Provider

Source: https://github.com/superagent-ai/vibekit/blob/main/packages/e2b/README.md

Installs the E2B sandbox provider for VibeKit using npm.

```bash
npm install @vibe-kit/e2b
```

--------------------------------

### Example Sandbox Status Output

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/cli/local-sandbox.mdx

An example of the output format when checking the sandbox status, indicating whether it's enabled, the type, and its readiness.

```text
📦 Sandbox Status
──────────────────────────────────────────────────
Status: ENABLED
Type: docker
Source: CLI option
Runtime: docker
Available: YES
Image: vibekit-sandbox:latest
Image Exists: YES
Ready: YES
```

--------------------------------

### Install Dagger CLI (macOS)

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/supported-sandboxes/dagger.mdx

Installs the Dagger command-line interface on macOS using Homebrew.

```bash
brew install dagger/tap/dagger
```

--------------------------------

### Install and Run VibeKit CLI

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/cli/index.mdx

Installs the VibeKit CLI globally using npm and demonstrates running the Claude Code agent with enhanced security.

```bash
# Install globally
npm install -g vibekit

# Run Claude Code with enhanced security
vibekit claude
```

--------------------------------

### Install VibeKit Auth

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/auth/overview.mdx

Installs the VibeKit authentication library using npm. This command is used to add the library to your project's dependencies.

```bash
npm install @vibe-kit/auth
```

--------------------------------

### VibeKit Sandbox Options

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/cli/quick-reference.mdx

Demonstrates various sandbox configurations for running agents, including 'none', 'docker', 'docker' with no network access, and using a fresh container.

```bash
# No sandbox (default, fast startup)
vibekit claude --sandbox none "Fix the bug"

# Docker sandbox (complete isolation)
vibekit claude --sandbox docker "Run untrusted code"

# Docker with no network access (maximum security)
vibekit claude --sandbox docker --no-network "Secure development"

# Use fresh container instead of persistent one
vibekit claude --sandbox docker --fresh-container "Clean environment"
```

--------------------------------

### Installing Required Agents

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/cli/installation.mdx

Installs necessary coding agents like Claude Code CLI and Gemini CLI, which are required for VibeKit to function with specific AI models.

```bash
# Install Claude Code CLI
npm install -g @anthropic/claude-code

# Install Gemini CLI (if available)
# Follow Gemini CLI installation instructions
```

--------------------------------

### VibeKit Quick Start with E2B and GitHub

Source: https://github.com/superagent-ai/vibekit/blob/main/LLM.md

Demonstrates initializing VibeKit with an E2B sandbox provider, an OpenAI Codex agent, and GitHub integration for code generation.

```typescript
import { VibeKit } from '@vibe-kit/vibekit';
import { createE2BProvider } from '@vibe-kit/e2b';

// Create sandbox provider
const e2bProvider = createE2BProvider({
  apiKey: 'your-e2b-key',
  templateId: 'vibekit-codex'  // or vibekit-claude, vibekit-gemini, etc.
});

// Create VibeKit instance with builder pattern
const vibekit = new VibeKit()
  .withAgent({
    type: 'codex',
    provider: 'openai',
    apiKey: 'your-openai-key',
    model: 'codex-mini-latest'
  })
  .withSandbox(e2bProvider)
  .withGithub({
    token: 'your-github-token',
    repository: 'owner/repo'
  });

// Set up event listeners
vibekit.on('update', (message) => {
  console.log('Update:', message);
});

vibekit.on('error', (error) => {
  console.error('Error:', error);
});

// Generate code
const result = await vibekit.generateCode(
  'Add error handling to login function',
  'code'  // mode: 'code' or 'ask'
);

// Clean up
await vibekit.kill();
```

--------------------------------

### Python SDK Example

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/sdk/index.mdx

A Python code snippet illustrating how to initialize and use a VibeKit agent. This example shows basic agent interaction and command execution.

```python
from vibekit.agent import Agent

agent = Agent(name="my-python-agent", provider="openai")
result = agent.run("print('Hello from Python agent!')")
print(result)
```

--------------------------------

### Start Local Development Server

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/README.md

Runs the Mintlify development server to preview documentation changes locally. This command should be executed at the root of your documentation project, where 'docs.json' is located.

```bash
mintlify dev
```

--------------------------------

### VibeKit SDK Configuration Example

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/api-reference/configuration.mdx

A complete example demonstrating the configuration of the VibeKit SDK, including setting up an agent, sandbox, GitHub integration, working directory, and secrets. It also shows how to use the configured instance to generate code.

```typescript
import { VibeKit } from "@vibe-kit/sdk";
import { createE2BProvider } from "@vibe-kit/e2b";

const e2bProvider = createE2BProvider({
  apiKey: process.env.E2B_API_KEY!,
  templateId: "vibekit-claude",
});

const vibeKit = new VibeKit()
  .withAgent({
    type: "claude",
    provider: "anthropic",
    apiKey: process.env.ANTHROPIC_API_KEY!,
    model: "claude-sonnet-4-20250514",
  })
  .withSandbox(e2bProvider)
  .withGithub({
    token: process.env.GITHUB_TOKEN!,
    repository: "your-org/your-repo",
  })
  .withWorkingDirectory("/app")
  .withSecrets({
    "DATABASE_URL": process.env.DATABASE_URL!,
    "API_KEY": process.env.API_KEY!,
  });

// Use the configured VibeKit instance
const result = await vibeKit.generateCode({
  prompt: "Create a web server",
  mode: "ask"
});
```

--------------------------------

### Troubleshooting Agent Not Found Errors

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/cli/installation.mdx

Addresses 'command not found' errors for AI agents like Claude or Gemini, providing steps to reinstall the agent and verify its installation.

```bash
# For Claude Code CLI
npm install -g @anthropic/claude-code

# Verify installation
claude --version

# Set up global aliases (optional)
vibekit setup-aliases
```

--------------------------------

### VibeKit CLI Usage Examples

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/cli/overview.mdx

Demonstrates common VibeKit CLI commands for running Claude and Gemini agents, managing logs, analytics, Docker, and the dashboard.

```bash
# Run Claude with security features
vibekit claude "Fix the bug in src/app.js"

# Run with Docker sandbox (maximum security)
vibekit claude --sandbox docker "Add user authentication"

# Run Gemini with network access
vibekit gemini --network "Create a web scraper"

# View logs and analytics
vibekit logs --agent claude --lines 100
vibekit analytics --days 7

# Open analytics dashboard
vibekit dashboard

# Manage Docker containers
vibekit docker --status
```

--------------------------------

### Running VibeKit Agents

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/cli/quick-reference.mdx

Examples of running different agents like Claude and Gemini, with options for sandbox environments, network access, and passing agent-specific arguments.

```bash
# Run Claude with default settings
vibekit claude "Create a REST API"

# Run Claude with Docker sandbox (maximum security)
vibekit claude --sandbox docker "Add authentication"

# Run Gemini with network access
vibekit gemini --network "Create a web scraper"

# Pass additional arguments to the underlying agent
vibekit claude --help
vibekit claude --model claude-3-5-sonnet-20241022 "Generate code"
```

--------------------------------

### Uninstalling VibeKit CLI

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/cli/installation.mdx

Commands to remove the VibeKit CLI from the system using npm or yarn.

```bash
npm uninstall -g vibekit
```

```bash
yarn global remove vibekit
```

--------------------------------

### Cloudflare Worker Setup with VibeKit

Source: https://github.com/superagent-ai/vibekit/blob/main/packages/cloudflare/README.md

Provides a complete Cloudflare Worker example that handles proxying to the sandbox and processing VibeKit requests.

```typescript
import { VibeKit } from "@vibe-kit/sdk";
import { createCloudflareProvider, proxyToSandbox } from "@vibe-kit/cloudflare";

// Export the Sandbox class for Durable Objects
export { Sandbox } from "@cloudflare/sandbox";

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    // Handle preview URL routing for exposed ports
    const proxyResponse = await proxyToSandbox(request, env);
    if (proxyResponse) return proxyResponse;

    // Handle VibeKit requests
    if (new URL(request.url).pathname === "/vibekit") {
      const provider = createCloudflareProvider({
        env,
        hostname: request.headers.get("host") || "localhost",
      });

      const vibeKit = new VibeKit()
        .withSandbox(provider)
        .withAgent({
          type: "claude",
          provider: "anthropic",
          apiKey: process.env.ANTHROPIC_API_KEY!,
          model: "claude-sonnet-4-20250514",
        })

      const result = await vibeKit.generateCode({
        prompt: "Create a Node.js web server",
        mode: "code",
      });

      return new Response(JSON.stringify(result), {
        headers: { "Content-Type": "application/json" },
      });
    }

    return new Response("Not Found", { status: 404 });
  },
};
```

--------------------------------

### Basic Test Execution Example

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/api-reference/run-tests.mdx

Demonstrates how to initialize VibeKit and run tests on the current branch, logging the exit code and output.

```javascript
import { VibeKit } from 'vibekit';

const vibekit = new VibeKit({
  agent: {
    type: 'codex',
    model: {
      provider: 'openai',
      name: 'gpt-4',
      apiKey: process.env.OPENAI_API_KEY
    }
  },
  environment: 'e2b',
  sessionId: 'test-session'
});

// Run tests on current branch
const result = await vibekit.runTests({});

console.log('Tests completed with exit code:', result.exitCode);
console.log('Test output:', result.stdout);
```

--------------------------------

### VibeKit Event Listeners and Code Generation

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/sdk/quickstart.mdx

Sets up event listeners for 'update' and 'error', generates code based on a prompt, retrieves the host URL, and cleans up the VibeKit instance.

```typescript
// Add event listeners
vibeKit.on("update", (update) => {
  console.log("Update:", update);
});

vibeKit.on("error", (error) => {
  console.error("Error:", error);
});

// Generate code
const result = await vibeKit.generateCode({
  prompt: "Create a simple web app that displays a list of users",
  mode: "code",
});

// Get host URL (optional)
const host = await vibeKit.getHost(3000);

// Clean up when done
await vibeKit.kill();

console.log("Result:", result);
console.log("Host:", host);
```

--------------------------------

### VibeKit Global Alias Setup and Usage

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/cli/configuration-files.mdx

Guides on enabling, setting up, and using global command aliases for VibeKit, along with diagnostic commands.

```bash
# Enable in settings
vibekit  # Toggle aliases to enabled

# Install aliases to shell
vibekit setup-aliases

# Restart terminal or reload shell
source ~/.zshrc

# Instead of: vibekit claude "Generate code"
claude "Generate code"

# Instead of: vibekit gemini "Ask question"
gemini "Ask question"

# Check alias setup
vibekit diagnose-aliases
```

--------------------------------

### Project Structure Overview

Source: https://github.com/superagent-ai/vibekit/blob/main/templates/v0-clone/README.md

Provides a high-level overview of the project's directory structure, highlighting key directories like app, components, convex, lib, providers, and public.

```typescript
├── app/                    # Next.js App Router
│   ├── actions/            # Server actions
│   ├── api/                # API routes
│   └── session/            # Session pages
├── components/             # Reusable UI components
│   └── ui/                 # shadcn/ui components
├── convex/                 # Convex schema and functions
├── lib/                    # Utility libraries and configurations
├── providers/              # React providers (auth, convex, theme)
├── public/                 # Static assets

```

--------------------------------

### VibeKit Proxy Testing Endpoints

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/proxy/configuration.mdx

Provides examples for testing the VibeKit Proxy's health status and sending requests to a specific model using cURL.

```bash
# Check if proxy is running with your config
curl http://localhost:8080/health
```

```bash
# Test a specific model
curl -X POST http://localhost:8080/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer your-api-key" \
  -d '{
    "model": "gpt-5",
    "messages": [{"role": "user", "content": "Hello"}]
  }'
```

--------------------------------

### Basic Usage of resume()

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/api-reference/resume-sandbox.mdx

Demonstrates the basic workflow of initializing VibeKit, generating code, pausing the sandbox, resuming it using `vibeKit.resume()`, and then continuing with code generation.

```typescript
const vibeKit = new VibeKit({
  agent: {
    type: "codex",
    // ... other config
  }
});

// Generate some code first to create a sandbox
await vibeKit.generateCode("console.log('Hello World')", "code");

// Pause the sandbox
await vibeKit.pause();
console.log("Sandbox paused");

// Resume the sandbox
await vibeKit.resume();
console.log("Sandbox resumed - ready for more operations");

// Continue generating code
await vibeKit.generateCode("console.log('Back online!')", "code");
```

--------------------------------

### Vibekit Migration Guide: Docker Hub to Universal Registry

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/supported-sandboxes/dagger.mdx

Provides a migration example for updating Vibekit configurations from the older `dockerHubUser` parameter to the recommended universal `registryUser` and `registryName` parameters.

```typescript
// Old configuration (still supported)
const provider = createLocalProvider({
  dockerHubUser: "myusername"
});

// New configuration (recommended)
const provider = createLocalProvider({
  registryUser: "myusername",     // Universal field
  registryName: "dockerhub"       // Explicit registry selection
});
```

--------------------------------

### Configuring Environment Variables for API Keys

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/cli/installation.mdx

Sets environment variables for API keys required by AI providers like Anthropic (Claude) and Google (Gemini), and optionally configures proxy settings.

```bash
# For Claude
export ANTHROPIC_API_KEY="sk-ant-..."

# For Gemini
export GOOGLE_API_KEY="..."

# For proxy configuration (optional)
export HTTP_PROXY="http://proxy.example.com:8080"
```

```bash
echo 'export ANTHROPIC_API_KEY="sk-ant-..."' >> ~/.zshrc
source ~/.zshrc
```

--------------------------------

### Set Up Environment Variables

Source: https://github.com/superagent-ai/vibekit/blob/main/templates/v0-clone/README.md

Creates a .env.local file to configure essential API keys and URLs for Anthropic Claude, Northflank, Convex, and GitHub OAuth. These are crucial for the application's functionality.

```bash
# Anthropic Claude API Key
ANTHROPIC_API_KEY=your_anthropic_api_key_here

# Northflank Configuration
NORTHFLANK_API_KEY=your_northflank_api_key_here
NORTHFLANK_PROJECT_ID=your_northflank_project_id_here

# Convex Configuration
NEXT_PUBLIC_CONVEX_URL=your_convex_url_here

# GitHub OAuth Configuration
AUTH_GITHUB_ID=your_github_client_id
AUTH_GITHUB_SECRET=your_github_client_secret
```

--------------------------------

### VibeKit ClaudeAuth Library API Usage

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/agents/claude-code.mdx

Provides examples of common operations using the `ClaudeAuth` library, including authentication, checking authentication status, getting valid tokens, exporting, importing, and logging out.

```typescript
import { ClaudeAuth } from '@vibe-kit/auth';

// Authenticate and get token
const token = await ClaudeAuth.authenticate();

// Check if authenticated
const isAuthenticated = await ClaudeAuth.isAuthenticated();

// Get valid token (auto-refresh if needed)
const accessToken = await ClaudeAuth.getValidToken();

// Export token
const exportedToken = await ClaudeAuth.exportToken('full');

// Import token
await ClaudeAuth.importToken({ refreshToken: 'your-refresh-token' });

// Clear authentication
await ClaudeAuth.logout();
```

--------------------------------

### Vibekit Configuration File

Source: https://github.com/superagent-ai/vibekit/blob/main/packages/cli/README.md

Example JSON configuration file for Vibekit, showing settings for agents, logging, and sandboxing.

```json
{
  "agents": {
    "claude": {
      "command": "claude", 
      "args": [],
      "env": {},
      "sandbox": {
        "enabled": true,
        "autoBackup": true,
        "autoSync": true
      }
    }
  },
  "logging": {
    "level": "info",
    "debug": false,
    "retention": {
      "days": 30,
      "maxFiles": 100
    }
  },
  "sandbox": {
    "defaultEnabled": true,
    "backupOnStart": true,
    "syncOnExit": true
  }
}
```

--------------------------------

### Browser Token Management

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/auth/browser.mdx

Provides examples for managing authentication tokens within the browser. This covers checking the authentication status, retrieving a valid access token (with automatic refresh capabilities), and handling cases where no token is available.

```typescript
// Check authentication status
const isAuthenticated = await auth.isAuthenticated();

// Get valid token (auto-refresh if needed)
const accessToken = await auth.getValidToken();

// Use token with AI provider APIs
if (!accessToken) {
  // Handle authentication flow...
}
```

--------------------------------

### Best Practice: .env.example Template

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/cli/environment-variables.mdx

Illustrates creating a template file (.env.example) to guide team members on required environment variables.

```bash
# .env.example
ANTHROPIC_API_KEY=your-anthropic-key-here
OPENAI_API_KEY=your-openai-key-here
GITHUB_TOKEN=your-github-token-here
GITHUB_REPOSITORY=owner/repo
```

--------------------------------

### VibeKit getHost Method Signature and Usage

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/api-reference/get-host.mdx

Demonstrates the TypeScript signature of the getHost method and provides examples of how to use it to access services running on different ports within a sandbox environment. Includes setup with VibeKit and execution of commands.

```typescript
import { VibeKit } from 'vibekit';

const vibekit = new VibeKit(config);

// Start a web server on port 3000
await vibekit.executeCommand('npm run dev -- --port 3000', {
  background: true
});

// Get the host URL for the web server
const hostUrl = vibekit.getHost(3000);
console.log('Web server accessible at:', hostUrl);
// Output: https://3000-sandbox-id.e2b.dev

// Start an API server
await vibekit.executeCommand('python -m http.server 8080', {
  background: true
});

// Get the host URL for the API
const apiUrl = vibekit.getHost(8080);
console.log('API server accessible at:', apiUrl);
// Output: https://8080-sandbox-id.e2b.dev

// Start a database server
await vibekit.executeCommand('mongod --port 27017', {
  background: true
});

// Get the host URL for database access
const dbHost = vibekit.getHost(27017);
console.log('Database accessible at:', dbHost);
// Output: https://27017-sandbox-id.e2b.dev
```

--------------------------------

### EC2 User Data Script for Docker Deployment

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/proxy/aws-deployment.mdx

A bash script to configure an EC2 instance for running the VibeKit proxy. It installs Docker and Docker Compose, sets up the application directory, creates a docker-compose.yml file, and starts the proxy service in detached mode.

```bash
#!/bin/bash
yum update -y
yum install -y docker

# Start Docker
systemctl start docker
systemctl enable docker

# Add ec2-user to docker group
usermod -a -G docker ec2-user

# Install Docker Compose
curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose

# Create app directory
mkdir -p /opt/vibekit-proxy

# Create docker-compose.yml
cat > /opt/vibekit-proxy/docker-compose.yml << EOF
version: '3.8'
services:
  vibekit-proxy:
    image: vibekit/proxy:latest
    ports:
      - "8080:8080"
    environment:
      - NODE_ENV=production
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
EOF

# Start the application
cd /opt/vibekit-proxy
docker-compose up -d

```

--------------------------------

### Setup GitHub Container Registry for Dagger

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/supported-sandboxes/dagger.mdx

Provides bash commands to set the GitHub token, log in to GHCR, and initialize VibeKit with Dagger and GHCR.

```bash
# Set GitHub token (requires packages:write permission)
export GITHUB_TOKEN=ghp_xxxxxxxxxxxx

# Login to GHCR
echo $GITHUB_TOKEN | docker login ghcr.io -u USERNAME --password-stdin

# Initialize with GHCR
vibekit init --providers dagger --agents claude,codex \
  --registry ghcr --registry-user github-username
```

--------------------------------

### Cloud Deployment for VibeKit Proxy

Source: https://github.com/superagent-ai/vibekit/blob/main/docs/cli/proxy-server.mdx

Examples of deploying the VibeKit proxy to cloud platforms like Google Cloud Run.

```bash
# Google Cloud Run (after building and pushing your image)
gcloud run deploy vibekit-proxy --image vibekit-proxy --port 8080
```

--------------------------------

### Install Northflank Provider

Source: https://github.com/superagent-ai/vibekit/blob/main/packages/northflank/README.md

Installs the @vibe-kit/northflank package using npm.

```bash
npm install @vibe-kit/northflank
```
Tokens:
Raw