🎮 CursorToys

The Ultimate Productivity Toolkit for Cursor AI

Supercharge your workflow • Test APIs in-editor • Share instantly • Collaborate effortlessly

Installation • Features • Configuration • Support

🎯 What is CursorToys?

CursorToys transforms Cursor AI into a collaborative powerhouse. Share AI configurations instantly, test APIs without leaving your editor, optimize files and clipboard content, and build reusable command libraries that work across all your projects.

Stop context-switching. Everything you need to maximize Cursor AI productivity, in one extension.

Why Developers Love It

✨ One-click sharing     → No more copy-pasting commands
🚀 In-editor API testing → Zero external tools, environment variables support
📚 Personal libraries    → Reusable across all projects
👥 Team collaboration    → Sync AI configs instantly
🗜️ File optimization    → Minify JSON, HTML, CSS, JS instantly
📋 Smart clipboard      → Auto-detect and optimize clipboard content

🎬 See It In Action

Generate shareable links with one click

📥 Import Configurations

Import Commands Import team configs in seconds

📚 Personal Command Library

Personal Commands Visual tree view for all your commands and prompts

✨ Features

Share AI configurations in one click — No more screenshots or copy-pasting.

🎯 One-Click Share Links — Convert commands, rules, and prompts to shareable deeplinks or CursorToys format
⌨️ Fast Import — Cmd+Shift+I to import from any link (deeplink or CursorToys)
🔄 Multiple Formats — Deeplink, web URL, CursorToys compressed format, or custom protocols
👥 Team Sync — Everyone uses the same AI instructions
📦 CursorToys Format — New compressed format ideal for large files (no URL length limits)

🌐 In-Editor API Testing

Test APIs without leaving Cursor — Full REST client built-in.

🚀 Execute Requests — Run HTTP requests from .req files with CodeLens
📝 Multiple Formats — cURL commands or structured JSON
⚡ Performance Tracking — See execution time for each request
🎨 Syntax Highlighting — Beautiful highlighting for requests and responses
🌍 Environment Variables — Use {{variableName}} for dynamic values
🔧 Multiple Environments — Switch between dev, staging, prod instantly
💾 Auto-Save Responses — Or preview-only mode for quick tests

📚 Personal Command Libraries

Build reusable libraries — Commands that work across all projects.

🗂️ Visual Tree View — Browse all personal commands and prompts in Explorer sidebar
🏠 Personal + Project — Separate libraries for personal and project-specific
✏️ Easy Management — Rename, delete, reveal in folder
🔍 Smart Filtering — Filter by file extensions
📂 Hierarchical Folders — Organize in subfolders with drag-and-drop
🎯 Drag & Drop — Move commands/prompts between folders easily

🗜️ File Minification & Optimization

Optimize files and clipboard content — Reduce file sizes instantly.

📦 Minify Files — One-click minification for JSON, HTML, XML, CSS, SVG, JS, TS
📋 Clipboard Minification — Minify clipboard content with auto-detection
📊 Statistics — See original size, minified size, and savings percentage
⚙️ Configurable — Customize output suffix and behavior
🎯 Context Menu — Right-click any supported file → Minify File

💬 Chat Integration

Send code to Cursor AI faster — No manual copy-paste.

✂️ Send Selection — Right-click → Send to Chat
🔗 Prompt Deeplinks — Generate shareable prompt links from selected code
📝 Custom Text — Send any text directly to chat
📍 Context Included — File path, language, and line numbers auto-added

🚀 Quick Start

Installation

Option 1: VS Code Marketplace (Recommended)

VS Code Marketplace
Open VSX Registry (for Cursor and other editors)

Option 2: Manual Installation

Download the latest .vsix from GitHub Releases
Open Cursor/VS Code
Go to Extensions (Cmd+Shift+X)
Click ... → Install from VSIX...
Select the downloaded file

First Steps

Open Command Palette (Cmd+Shift+P)
Type "CursorToys" to see all available commands
Try "CursorToys: Generate Share Link" on a command file
Press Cmd+Shift+I to import a shared link

📖 Usage Examples

Right-click any command file → Choose your preferred sharing format:

Option 1: Deeplink Format (Traditional)

Best for: Direct sharing in Slack, Discord, or platforms with URL length support

# Deeplink copied to clipboard!
cursor://godrix.cursor-toys/command?text=...

# Or web format
https://cursor.com/link/command?text=...

Limitation: Maximum 8,000 characters (URL-encoded)

Option 2: CursorToys Format (New in v1.1)

Best for: Large files or when deeplinks exceed length limit

# CursorToys shareable copied to clipboard!
cursortoys://COMMAND:filename:compressedData...

Advantages:

✅ No URL length limit (uses gzip compression + base64)
✅ Ideal for large commands, rules, and prompts
✅ Smaller size (60-80% compression ratio)
✅ Faster to share and import

Send to team → They press Cmd+Shift+I → Command imported ✨

Note: The extension automatically detects the format when importing.

🌐 HTTP Request Testing

Create a .req file in .cursor/http/:

## Get Users
GET {{BASE_URL}}/api/users
Authorization: Bearer {{API_TOKEN}}

## Create User  
POST {{BASE_URL}}/api/users
Content-Type: application/json

{
  "name": "John Doe",
  "email": "john@example.com"
}

Set up environment variables in .cursor/http/environments/.env.dev:

BASE_URL=http://localhost:3000
API_TOKEN=your-dev-token-here

Click CodeLens "Send Request" → Variables replaced → Response appears instantly! ⚡

🗜️ Minify Files

Optimize any file with one click:

# Right-click any JSON, HTML, XML, CSS, SVG, JS, or TS file
→ "Minify File"
→ Creates file.min.ext with optimized content

Or minify clipboard content:

# Copy large JSON/HTML/CSS to clipboard
Cmd+Shift+P → "Trim & Minify Clipboard"
→ Clipboard optimized automatically!

Statistics shown: Savings: 15.3KB (68.2%) | Original: 22.4KB → Minified: 7.1KB

📚 Personal Commands

Your personal commands in ~/.cursor/commands/ appear in the sidebar:

📁 Personal Commands
  ├─ 📄 code-review.md
  ├─ 📄 refactor-helper.md
  └─ 📄 bug-analyzer.md

Right-click → Generate link, rename, delete, or reveal in folder.

⚙️ Configuration

Send selected code directly to Cursor chat
Custom text injection for faster context building
Streamlined AI interaction workflow

🚀 Installation

Quick Install (Recommended)

For Cursor/VS Code:

Open Extensions (Cmd+Shift+X / Ctrl+Shift+X)
Search for "Cursor Command Toys"
Click Install

Direct Links:

VS Code Marketplace
Open VSX Registry (for Cursor and other editors)

Manual Install

Download the latest .vsix from GitHub Releases
Open Command Palette (Cmd+Shift+P / Ctrl+Shift+P)
Run "Extensions: Install from VSIX..."
Select the downloaded file

That's it! The extension is ready to enhance your Cursor experience.

📖 Quick Start Guide

🎯 Get Started in 60 Seconds

Step 1: Test an API (30 seconds)

# Create .cursor/http/api-test.req in your project
curl -X GET https://api.github.com/users/octocat

Click the "Send Request" link that appears above → See formatted response!

Step 2: Share a Command (20 seconds)

Create .cursor/commands/my-command.md
Right-click → "Generate Cursor Toys Command"
Link copied! Share it anywhere.

Step 3: Import Team Config (10 seconds)

Press Cmd+Shift+I (Mac) or Ctrl+Shift+I (Windows/Linux)
Paste a deeplink
Done! File created automatically.

🎯 Daily Workflow Scenarios

Scenario 1: Testing an API Endpoint

Create .cursor/http/api-test.req in your project
Write your curl command or JSON request
Click the "Send Request" CodeLens link
View formatted response with execution time

Create your command in .cursor/commands/
Right-click → "Generate Cursor Toys Command"
Share the link in your team chat
Team members import with Cmd+Shift+I

Scenario 3: Building a Personal Command Library

Use the Personal Commands tree view
Save frequently used commands as personal commands
Access them from any project instantly
Organize and manage your AI command collection

Navigate to the configuration file you wish to share:
- .cursor/commands/ or .claude/commands/ (for Commands)
- .cursor/rules/ (for Rules)
- .cursor/prompts/ (for Prompts)
Right-click the file and select the specific "Generate Cursor Toys..." option (e.g., "Generate Cursor Toys Command").
The share link will be automatically copied to your clipboard.

Method 2: CodeLens (Direct In-File Access)

Open any file in .cursor/commands/, .claude/commands/, .cursor/rules/, or .cursor/prompts/.
Click the CodeLens link displayed at the top of the file.
The deeplink will be generated and copied.

Importing Shared Links

Import Commands, Rules, and Prompts

Method 1: Keyboard Shortcut

Press Ctrl+Shift+I (Windows/Linux) or Cmd+Shift+I (Mac).
Paste the deeplink into the input box.
For commands, choose where to save:
- Project commands: Save to .cursor/commands/ or .claude/commands/ in the current workspace (based on configuration, project-specific)
- Personal commands: Save to ~/.cursor/commands/ or ~/.claude/commands/ (based on configuration, available in all projects)
The file will be automatically created and imported into the appropriate directory.

Method 2: Command Palette

Press Cmd+Shift+P (Mac) or Ctrl+Shift+P (Windows/Linux).
Type "Import Cursor Toys".
Paste the deeplink, and for commands, choose the save location.
The file will be created.

Saving Commands as User Commands

You can move existing project commands to your personal commands folder so they're available across all projects:

Right-click on any file in .cursor/commands/ or .claude/commands/ folder.
Select "Cursor Toys" submenu.
Choose "Save as User Command".
The command will be copied to ~/.cursor/commands/ or ~/.claude/commands/ (based on your configuration) and you'll be asked if you want to remove the original file from the workspace.

🌐 HTTP Request Execution

Test APIs without leaving your editor. Execute HTTP requests directly from your workspace with full syntax highlighting, automatic response formatting, and performance tracking.

Visual Demo

Send HTTP Request

Creating HTTP Request Files

Important: HTTP request files must be located in the .cursor/http/ folder (or subfolders within it) to be recognized by the extension.

Create files with .req or .request extension in .cursor/http/ containing your HTTP requests in one of two formats:

Format 1: Curl Command

curl -X POST https://api.example.com/users \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer token123" \
  -d '{"name": "John Doe", "email": "john@example.com"}'

Format 2: Structured JSON

{
  "method": "POST",
  "url": "https://api.example.com/users",
  "headers": {
    "Content-Type": "application/json",
    "Authorization": "Bearer token123"
  },
  "body": {
    "name": "John Doe",
    "email": "john@example.com"
  }
}

Executing Requests

Method 1: CodeLens (Recommended)

Open any .req or .request file in .cursor/http/ folder
Click the "Send Request" link that appears above the request (or above each section if you have multiple requests)
The request will be executed and the response will be displayed

Method 2: Command Palette

Open any .req or .request file in .cursor/http/ folder
Press Cmd+Shift+P (Mac) or Ctrl+Shift+P (Windows/Linux)
Type "CursorToys: Send HTTP Request" and select it
The request will be executed

Note: Files must be in .cursor/http/ (or subfolders) to be recognized. The extension will not show CodeLens links for .req files outside this folder.

Multiple Requests in One File

You can organize multiple requests in a single file using markdown sections. Create the file in .cursor/http/:

## Get User
curl -X GET https://api.example.com/users/123 \
  -H "Authorization: Bearer token123"

## Create User
curl -X POST https://api.example.com/users \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer token123" \
  -d '{"name": "John Doe"}'

Each section will have its own "Send Request" CodeLens link, allowing you to execute requests individually.

File Location Requirements

HTTP request files must be located in:

.cursor/http/ (root level)
.cursor/http/subfolder/ (any subfolder)

Supported file extensions:

.req
.request

Example file structure:

project/
  .cursor/
    http/
      api-tests.req
      auth/
        login.request
      users.req

Response Files

When a request is executed:

If httpRequestSaveFile is true: The response is saved to a .res or .response file (same name as request file, with response extension)
If httpRequestSaveFile is false: The response is shown in a preview tab (not saved to disk)

Response files include:

HTTP status code and status text
Response headers
Formatted response body (JSON and XML are automatically formatted)
Execution time in the file name/title

Configuration

Configure HTTP request behavior in your settings:

{
  "cursorToys.httpRequestTimeout": 10,
  "cursorToys.httpRequestSaveFile": false
}

cursorToys.httpRequestTimeout: Timeout in seconds for HTTP requests (default: 10 seconds)
cursorToys.httpRequestSaveFile: Save HTTP response to file. If false, only shows preview without saving (default: false)

Requirements

curl: The extension uses curl command-line tool to execute requests. Make sure curl is installed and available in your system PATH.

HTTP Environment Variables

Manage environment-specific configurations for your API requests.

Setting Up Environments

Initialize Environments Folder:
- Navigate to .cursor/http/ folder in your workspace
- Right-click → "CursorToys: Create Environments Folder"
- Or use Command Palette → "CursorToys: Create Environments Folder"

Environment Files Structure:

.cursor/http/
  environments/
    .env              # Default environment
    .env.dev          # Development environment
    .env.staging      # Staging environment
    .env.prod         # Production environment
    .env.example      # Template with documentation
    .gitignore        # Protects sensitive data

Create Environment Variables:

# .cursor/http/environments/.env.dev
BASE_URL=http://localhost:3000
API_KEY=your-dev-api-key
AUTH_TOKEN=dev-token-123
TIMEOUT=10000
API_VERSION=v1

Using Variables in Requests

Use {{variableName}} syntax in your .req files:

## Get User Profile
GET {{BASE_URL}}/api/{{API_VERSION}}/users/me
Authorization: Bearer {{AUTH_TOKEN}}
Content-Type: application/json

## Update User
PUT {{BASE_URL}}/api/{{API_VERSION}}/users/123
Authorization: Bearer {{AUTH_TOKEN}}
Content-Type: application/json

{
  "name": "Updated Name"
}

Switching Environments

Method 1: Command Palette

Press Cmd+Shift+P (Mac) or Ctrl+Shift+P (Windows/Linux)
Type "CursorToys: Select HTTP Environment"
Choose environment from list (dev, staging, prod, etc.)

Method 2: Configuration

{
  "cursorToys.httpDefaultEnvironment": "dev"
}

Environment Management Commands

Command	Description
CursorToys: Select HTTP Environment	Switch between environments
CursorToys: Open Environments Folder	Open environments folder
CursorToys: Create Environment	Create new environment file
CursorToys: Create Environments Folder	Create default structure

Features

✅ Case-Insensitive: Variables match regardless of case
✅ Validation: Warns about unresolved variables before sending
✅ Caching: Fast variable lookup with automatic cache management
✅ Git Safe: Includes .gitignore to protect sensitive data
✅ Multiple Formats: Supports quoted and unquoted values

Variable File Format

# Comments start with #
KEY=value
KEY_WITH_QUOTES="value with spaces"
KEY_WITH_SINGLE='single quotes also work'

# Empty lines are ignored

# No spaces around = sign (best practice)
CORRECT=value
# INCORRECT = value  # spaces cause issues

🗜️ File Minification & Clipboard Optimization

Optimize your files and clipboard content to reduce size and improve performance.

Minifying Files

Supported File Types:

📄 JSON — Remove whitespace, compact structure
🌐 HTML — Remove comments, excess whitespace, line breaks
📋 XML — Remove comments, whitespace
🎨 CSS — Remove comments, whitespace, unnecessary semicolons
🖼️ SVG — Remove metadata, comments, optimize structure
💻 JavaScript — Remove comments and excess whitespace
📘 TypeScript — Remove comments and excess whitespace

Right-click any supported file in Explorer or editor
Select "CursorToys: Minify File"
Minified file created with configurable suffix (default: .min)
Statistics shown: Savings: 15.3KB (68.2%) | Original: 22.4KB → Minified: 7.1KB

Method 2: Editor Title

Open any supported file
Click minify icon (📦) in editor title bar
Minified file created automatically

Method 3: Command Palette

Open file to minify
Press Cmd+Shift+P (Mac) or Ctrl+Shift+P (Windows/Linux)
Type "CursorToys: Minify File"
Minified file created

Minifying Clipboard Content

Perfect for optimizing large JSON responses, HTML snippets, or CSS before pasting into chat.

Auto-Detection Mode (Recommended)

Copy content to clipboard
Press Cmd+Shift+P → "CursorToys: Trim & Minify Clipboard"
Content type auto-detected and minified
Optimized content replaces clipboard
Statistics shown

Manual Type Selection

Copy content to clipboard
Press Cmd+Shift+P → "CursorToys: Trim & Minify Clipboard (Select Type)"
Choose content type from list
Content minified based on selected type
Statistics shown

Minification Examples

JSON Minification

Before (234 bytes):

{
  "user": {
    "name": "John Doe",
    "email": "john@example.com",
    "age": 30
  }
}

After (71 bytes, 69.7% savings):

{"user":{"name":"John Doe","email":"john@example.com","age":30}}

HTML Minification

Before (312 bytes):

<!DOCTYPE html>
<html>
  <head>
    <title>Page Title</title>
  </head>
  <body>
    <!-- Comment -->
    <h1>Hello World</h1>
  </body>
</html>

After (89 bytes, 71.5% savings):

<!DOCTYPE html><html><head><title>Page Title</title></head><body><h1>Hello World</h1></body></html>

Configuration

{
  // Suffix for minified files (e.g., .min creates file.min.js)
  "cursorToys.minify.outputSuffix": ".min",
  
  // Preserve comments (future feature)
  "cursorToys.minify.preserveComments": false
}

Use Cases

Use Case 1: Optimize API Responses for Chat

Problem: Large JSON responses exceed chat context limits.

Solution:

Copy JSON response to clipboard
Run "Trim & Minify Clipboard"
Paste optimized JSON into chat
Result: More context available for AI

Use Case 2: Reduce Build Output Size

Problem: Production files too large.

Solution:

Right-click CSS/JS files → "Minify File"
Deploy .min versions
Result: Faster load times, reduced bandwidth

Use Case 3: Clean HTML Templates

Problem: HTML templates with excessive whitespace and comments.

Solution:

Open template file
Click minify icon in title bar
Use minified version in production
Result: Cleaner, smaller HTML files

Minification Statistics

After minification, you'll see detailed statistics:

✅ Clipboard minified! 
Savings: 15.3KB (68.2%) | Original: 22.4KB → Minified: 7.1KB

Savings: Amount of space saved (in KB)
Percentage: Reduction percentage
Original: Original file/clipboard size
Minified: Final size after minification

🔗 Link Formats & Distribution

Choose the link format that works best for your sharing needs:

Format	Example	Best For	Size Limit
Deeplink	`cursor://godrix.cursor-toys/prompt?text=...`	Direct sharing in Slack, Discord, or other tools that support native links	8,000 chars (URL-encoded)
Web Link	`https://cursor.com/link/prompt?text=...`	Blogs, documentation, forums, or any platform requiring HTTP links	8,000 chars (URL-encoded)
CursorToys	`cursortoys://PROMPT:name:compressedData`	Large files, team sharing, internal distribution	No limit (compressed)
Custom	`https://example.com/link/prompt?text=...`	Internal systems, custom distribution channels, or branded sharing	8,000 chars (URL-encoded)

CursorToys Format (New in v1.1)

The CursorToys format uses gzip compression and base64 encoding to overcome URL length limitations:

Format Structure:

cursortoys://TYPE:filename:compressedData

Example:

cursortoys://COMMAND:code-review:H4sIAAAAAAAAA...

Features:

📦 Compressed — Reduces size by 60-80% using gzip
⚡ Fast — Smaller payloads mean faster sharing
🚫 No Limits — No URL length restrictions
🔒 Safe — Base64 encoding ensures compatibility

How to Use:

Right-click any command/rule/prompt file
Choose "Share as CursorToys" instead of "Share as Deeplink"
Share the cursortoys:// link
Recipients import with Cmd+Shift+I (works automatically)

Comparison:

Metric	Deeplink	CursorToys
Size (1KB file)	~1,400 chars	~600 chars
Size (5KB file)	~7,000 chars	~2,000 chars
Size (10KB file)	❌ Exceeds limit	~3,500 chars
Compression	None	60-80%
Import Speed	Fast	Faster

All Configuration Options

Setting	Type	Default	Description
Link Generation
`cursorToys.linkType`	`string`	`"deeplink"`	Link format: `"deeplink"`, `"web"`, or `"custom"`
`cursorToys.customBaseUrl`	`string`	`""`	Custom base URL (only used when `linkType` is `"custom"`)
`cursorToys.allowedExtensions`	`string[]`	`["md", "mdc"]`	File extensions allowed for link processing
Folder Configuration
`cursorToys.baseFolder`	`string`	`"cursor"`	Base folder for commands and HTTP files (e.g., `"cursor"`, `"vscode"`, `"ai"`)
`cursorToys.commandsFolder`	`string`	`"cursor"`	Commands folder: `"cursor"` or `"claude"`
`cursorToys.personalCommandsView`	`string`	`"both"`	Personal commands view: `"both"`, `"cursor"`, or `"claude"`
HTTP Requests
`cursorToys.httpRequestTimeout`	`number`	`10`	HTTP request timeout in seconds
`cursorToys.httpRequestSaveFile`	`boolean`	`false`	Save HTTP responses to file (vs preview only)
`cursorToys.httpDefaultEnvironment`	`string`	`"dev"`	Default HTTP environment name
Minification
`cursorToys.minify.outputSuffix`	`string`	`".min"`	Suffix for minified files (e.g., `.min` creates `file.min.js`)
`cursorToys.minify.preserveComments`	`boolean`	`false`	Preserve comments when minifying (future feature)

🔄 VS Code Compatibility

CursorToys is fully compatible with VS Code, but some Cursor-specific features have limitations:

✅ Features That Work Fully in VS Code

Personal Commands/Prompts Management — Full library management with tree view
In-Editor API Testing — Complete HTTP request testing with environment variables
File Minification — All minification features work identically
Clipboard Processing — Smart clipboard optimization
Web-Based Sharing Links — Use https://cursor.com/link/ format
Custom Base Folder — Configure any folder name (e.g., .vscode, .ai)

⚠️ Features With Limitations in VS Code

Deeplinks (`cursor://`)

Limitation: Native cursor:// protocol links do not open automatically in VS Code (clicking won't trigger the extension).

Workaround: Deeplinks still work, but require manual import:

Copy the cursor:// deeplink
Open Command Palette (Cmd+Shift+P or Ctrl+Shift+P)
Run "CursorToys: Import Share Link" (or use shortcut Cmd+Shift+I / Ctrl+Shift+I)
Paste the deeplink when prompted
File will be created successfully

Alternative: Configure link type to web for better sharing:

{
  "cursorToys.linkType": "web"
}

Send to Chat

Limitation: Commands that send text to Cursor's AI chat won't work (no chat in VS Code).

Workaround: Manually copy the generated content and use it in a compatible chat interface or AI tool.

Rules and Prompts

Limitation: Rules and prompts are Cursor-specific features that may not work in VS Code.

Note: These features use the configured base folder, but their functionality depends on Cursor AI's architecture. They work for organization and sharing, but won't have the same behavior in VS Code as in Cursor IDE.

🚀 Using CursorToys with VS Code

Install the extension normally from VS Code Marketplace

Configure base folder in settings:

{
  "cursorToys.baseFolder": "vscode"
}

Set link type to web:
```
{
  "cursorToys.linkType": "web"
}
```
All file management and API testing features work perfectly!

Note: The baseFolder setting applies to all resources (commands, rules, prompts, HTTP). Rules and prompts are Cursor AI-specific features - they'll be stored in your configured folder but may not have full functionality outside of Cursor IDE.

💡 Real-World Use Cases

Use Case 1: Team Onboarding

Problem: New team members need to set up Cursor with project-specific commands and rules.

Solution:

Team lead creates standardized commands and rules
Generates deeplinks for each configuration
Shares links in onboarding documentation
New members import everything with Cmd+Shift+I in seconds

Result: Consistent AI behavior across the entire team from day one.

Use Case 2: API Development Workflow

Problem: Constantly switching between editor and terminal/Postman to test API endpoints.

Solution:

Create .req files in .cursor/http/ folder (or subfolders)
Set up environment variables in .cursor/http/environments/
Use {{VARIABLE}} syntax for dynamic values
Execute directly from editor with CodeLens
Switch environments via status bar or command palette
View formatted responses with execution times

Result: Faster iteration, better context, no context switching. Environment-specific testing without manual value changes.

Use Case 3: Optimizing Large API Responses

Problem: Large JSON responses from APIs take up too much space in chat context.

Solution:

Copy API response to clipboard
Run "Trim & Minify Clipboard" command
Paste optimized JSON into Cursor chat
More room for actual code and questions

Result: Better use of chat context limits, faster AI responses, cleaner conversations.

Use Case 4: Personal Productivity

Problem: Recreating the same commands in every new project.

Solution:

Build a personal command library using the tree view
Save frequently used commands as personal commands
Access them instantly in any project
Share your best commands with the community

Result: Your best AI workflows available everywhere, instantly.

Problem: Great AI prompts and commands get lost in Slack/Discord history.

Solution:

Create a command/prompt that solves a specific problem
Generate a shareable deeplink
Share in team channels or documentation
Team members can import and use immediately

Result: Knowledge becomes reusable, searchable, and permanent.

⚙️ Configuration & Customization

Workspace vs User Settings

Configure the extension at both workspace and user levels:

Workspace settings: Project-specific configurations (.vscode/settings.json)
User settings: Personal preferences that apply globally

Recommended Settings

{
  // Use web links for maximum compatibility
  "cursorToys.linkType": "web",
  
  // Save HTTP responses for API testing workflow
  "cursorToys.httpRequestSaveFile": true,
  "cursorToys.httpRequestTimeout": 30,
  "cursorToys.httpDefaultEnvironment": "dev",
  
  // Support both .cursor and .claude folders
  "cursorToys.commandsFolder": "cursor",
  "cursorToys.personalCommandsView": "both",
  
  // Minification settings
  "cursorToys.minify.outputSuffix": ".min"
}

📝 Limitations & Notes

URL Length Limit: Deeplink content cannot exceed 8,000 characters (after URL-encoding). The system will warn you if this limit is reached.
File Location for Deeplinks: Only files within .cursor/commands/, .claude/commands/, .cursor/rules/, or .cursor/prompts/ folders can be converted into share links.
HTTP Request File Location: HTTP request files (.req, .request) must be located in .cursor/http/ folder (or subfolders) to be recognized and executed.
HTTP Requests: Requires curl to be installed and available in your system PATH.

⌨️ Available Commands

Command	Description	Shortcut
Sharing & Import
CursorToys: Share as Deeplink (Command)	Generate deeplink for command	-
CursorToys: Share as Deeplink (Rule)	Generate deeplink for rule	-
CursorToys: Share as Deeplink (Prompt)	Generate deeplink for prompt	-
CursorToys: Share as CursorToys (Command)	Generate CursorToys compressed shareable for command	-
CursorToys: Share as CursorToys (Rule)	Generate CursorToys compressed shareable for rule	-
CursorToys: Share as CursorToys (Prompt)	Generate CursorToys compressed shareable for prompt	-
CursorToys: Import from Link	Import deeplink or CursorToys shareable to create file	`Ctrl+Shift+I` / `Cmd+Shift+I`
CursorToys: Save as User Command	Save project command as personal command	-
CursorToys: Save as User Prompt	Save project prompt as personal prompt	-
HTTP Requests
CursorToys: Send HTTP Request	Execute HTTP request from file	-
CursorToys: Select HTTP Environment	Switch HTTP environment	-
CursorToys: Open Environments Folder	Open environments folder	-
CursorToys: Create Environment	Create new environment file	-
CursorToys: Create Environments Folder	Create environments folder structure	-
Minification
CursorToys: Minify File	Minify current file	-
CursorToys: Trim & Minify Clipboard	Auto-detect and minify clipboard	-
CursorToys: Trim & Minify Clipboard (Select Type)	Select type and minify clipboard	-
Chat Integration
CursorToys: Send to Chat	Send custom text to Cursor chat	-
CursorToys: Send Selection to Chat	Send selected code to Cursor chat	-
CursorToys: Copy Selection as Prompt	Copy selection as prompt link	-

Pro Tip: Most commands are accessible via CodeLens (clickable links in your files) or context menu (right-click), so you rarely need to remember command names!

🎁 Developer Experience Benefits

⏱️ Time Savings

No more manual file copying: Import team configurations in seconds
No context switching: Test APIs without leaving your editor
Instant access: Personal commands available across all projects

🧠 Cognitive Load Reduction

Visual organization: Tree view makes command management intuitive
One-click actions: CodeLens eliminates menu navigation
Automatic formatting: Responses formatted for readability

🤝 Team Productivity

Consistency: Everyone uses the same AI configurations
Knowledge sharing: Best practices become reusable assets
Onboarding speed: New team members productive faster

🚀 Workflow Enhancement

Integrated testing: API testing where you code
Command library: Build once, use everywhere
Seamless sharing: Turn configurations into shareable links instantly

🤝 Contributing

We welcome contributions! Whether it's:

🐛 Bug reports
💡 Feature suggestions
📝 Documentation improvements
🔧 Code contributions

Please feel free to open an issue or submit a Pull Request.

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

Made with ❤️ for the Cursor community

CursorToys

Godrix

🎮 CursorToys

The Ultimate Productivity Toolkit for Cursor AI

🎯 What is CursorToys?

Why Developers Love It

🎬 See It In Action

🔗 Share Commands Instantly

📥 Import Configurations

📚 Personal Command Library

✨ Features

🔗 Instant Sharing & Collaboration

🌐 In-Editor API Testing

📚 Personal Command Libraries

🗜️ File Minification & Optimization

💬 Chat Integration

🚀 Quick Start

Installation

First Steps

📖 Usage Examples

🔗 Sharing Commands

Option 1: Deeplink Format (Traditional)

Option 2: CursorToys Format (New in v1.1)

🌐 HTTP Request Testing

🗜️ Minify Files

📚 Personal Commands

⚙️ Configuration

🚀 Installation

Quick Install (Recommended)

Manual Install

📖 Quick Start Guide

🎯 Get Started in 60 Seconds

🎯 Daily Workflow Scenarios

Scenario 1: Testing an API Endpoint

Scenario 2: Sharing a Team Command

Scenario 3: Building a Personal Command Library

🤝 Detailed Usage: Share and Import

Generating Share Links

Method 1: Context Menu (Recommended for Quick Generation)

Method 2: CodeLens (Direct In-File Access)

Importing Shared Links

Method 1: Keyboard Shortcut

Method 2: Command Palette

Saving Commands as User Commands

🌐 HTTP Request Execution

Visual Demo

Creating HTTP Request Files

Format 1: Curl Command

Format 2: Structured JSON

Executing Requests

Method 1: CodeLens (Recommended)

Method 2: Command Palette

Multiple Requests in One File

File Location Requirements

Response Files

Configuration

Requirements

HTTP Environment Variables

Setting Up Environments

Using Variables in Requests

Switching Environments

Environment Management Commands

Features

Variable File Format

🗜️ File Minification & Clipboard Optimization

Minifying Files

Method 1: Context Menu (Recommended)

Method 2: Editor Title

Method 3: Command Palette

Minifying Clipboard Content

Auto-Detection Mode (Recommended)

Manual Type Selection

Minification Examples

JSON Minification

HTML Minification

Configuration

Use Cases

Use Case 1: Optimize API Responses for Chat

Use Case 2: Reduce Build Output Size

Use Case 3: Clean HTML Templates

Deeplinks (`cursor://`)