🚀 VSCoder Copilot - AI-Powered Mobile Development

Transform your smartphone into an intelligent coding companion! VSCoder brings GitHub Copilot's AI power directly to your mobile device, enabling seamless development from anywhere in the world.

Perfect for: Code reviews on commute • Quick fixes from anywhere • AI-assisted mobile coding • Remote development workflows

🎉 Latest Update (v1.2.5): Enhanced mobile device validation with improved connection stability, production API integration, and optimized rate limiting for reliable mobile app connectivity!

✨ What Makes VSCoder Special

🌍 Code From Anywhere

Connect your phone to VS Code across any network (home, office, mobile data)
No complex setup, firewalls, or port forwarding needed
Secure 6-digit pairing codes connect devices instantly
NEW: Production-ready mobile app available on Google Play Store

🤖 Full GitHub Copilot on Mobile

Chat with AI using natural language: "Create a login component with validation"
Browse and edit your entire VS Code workspace from your phone
Real-time sync - your conversations appear everywhere instantly
NEW: Enhanced mobile device validation with improved connection reliability

⚡ Instant Setup (2 Minutes)

Install this extension from VS Code marketplace
Start the server with one command (VSCoder: Start Server)
Get pairing code from VS Code status bar (6 digits)
Install mobile app from Google Play Store or development build
Approve device when VS Code shows validation notification
Start coding - AI-powered development ready!

🔐 Enterprise Security

Your code never leaves your devices
Encrypted end-to-end communication
NEW: Enhanced device validation with user approval system
Pairing codes expire every 10 minutes for security
Device Validation Pipeline: VS Code shows user-friendly notification dialogs when mobile devices request access
User Authorization Required: You must explicitly approve each device connection attempt
Enhanced Device Information: Approval notifications show friendly device names and platform information with emojis
Granular Access Control: Approve or deny device access on a per-device basis with Approve/Deny/Details buttons
Session Management: Approved devices receive secure authentication tokens for ongoing access
Professional UI: Clean notification system at bottom-right instead of intrusive modal dialogs
Complete Disconnect Cleanup: Automatic cleanup when devices are removed or VS Code shuts down
Smart State Management: Proper cleanup of authentication state when profiles are deleted in mobile app

💡 Use Case: Review pull requests on your commute, fix bugs from the coffee shop, or get AI coding help while away from your desk!

🎯 Key Features

🤖 AI-Powered Mobile Coding

Full GitHub Copilot Integration: Access all AI models (GPT-4o, Claude, etc.) on mobile
Natural Language Prompts: "Add authentication to this component", "Fix this bug", "Optimize this function"
Context-Aware Responses: AI understands your entire workspace for better suggestions
Real-Time Chat Sync: Conversations sync automatically every 5 seconds between devices

📱 Complete Mobile Workspace

File Browser: Navigate your entire VS Code project from mobile
Code Editing: Make quick fixes and edits directly from your phone
Workspace Management: Switch between multiple projects with saved profiles
Live Updates: See changes instantly across all connected devices

🌐 Global Connectivity

Cross-Network Pairing: Connect from anywhere - home, office, mobile data, coffee shop WiFi
Zero Configuration: No port forwarding, VPNs, or network setup required
Secure Cloud Service: Production-grade infrastructure handles connections
6-Digit Pairing: Simple codes that expire for security

⚡ Developer-Friendly

Instant Setup: Working in under 2 minutes
Multiple AI Models: Switch between GPT-4o, Claude, and other Copilot models
Command Execution: Run terminal commands suggested by AI
Session Management: Persistent conversations across reconnections
Enhanced UX: Non-intrusive notifications replace modal dialogs for better workflow
Smart Cleanup: Automatic state management when devices connect or disconnect

🚀 Quick Start (2 Minutes)

Step 1: Install Extension

From VS Code: Search "VSCoder Copilot" in Extensions marketplace
Click Install and restart VS Code if prompted

Step 2: Start the Server

Press Ctrl+Shift+P (Windows/Linux) or Cmd+Shift+P (Mac)
Type: VSCoder: Start VSCoder Server
Press Enter - Server starts automatically on port 8080

Step 3: Get Your Pairing Code

Check status bar - You'll see a 6-digit code like 📱 123456
Or manually get code: Ctrl+Shift+P → VSCoder: Show Pairing Code
Code refreshes every 10 minutes for security

Step 4: Connect Mobile App

Download VSCoder mobile app (Android/iOS)
Google Play Store: Search "VSCoder Copilot" or use package com.emirbaycan.vscodercopilot
App Store: Search "VSCoder Copilot" (iOS version)
Open app → Settings → Profiles → "Pair with VS Code"
Enter the 6-digit code from step 3
⚠️ SECURITY VALIDATION: When the mobile device requests access, VS Code will show a user-friendly notification at the bottom-right with device information
⚡ USER APPROVAL REQUIRED: Click "Approve" in the notification to grant the mobile device access to your workspace
📱 DEVICE DETAILS: The notification shows friendly device information with emojis (e.g., "📱 Mobile device 'iPhone (iOS)' wants to connect")
🔐 SECURITY NOTE: Only approve devices you trust - this grants access to your VS Code workspace and files
✨ ENHANCED UX: Clean, non-intrusive notifications with Approve/Deny/Details buttons for better user experience
Connection established automatically after approval - works across any network!

Step 5: Start AI-Powered Coding! 🎉

Browse files on mobile from your VS Code workspace
Chat with AI: "Add error handling to this function"
See responses sync between VS Code and mobile instantly
Accept/reject AI suggestions with one tap

💡 Pro Tip: Your conversations automatically sync every 5 seconds between devices. Ask Copilot on mobile, see the response in VS Code!

📋 Available Commands

Essential commands for daily use:

VSCoder: Start VSCoder Server - Start mobile connectivity
VSCoder: Show Pairing Code - Display your current 6-digit code
VSCoder: Show Status - Check connection and server health
VSCoder: Generate New Pairing Code - Get a fresh code if needed
VSCoder: Run Diagnostics - Troubleshoot any connection issues

Advanced commands:

VSCoder: Test Copilot Bridge - Verify AI integration
VSCoder: Stop VSCoder Server - Stop mobile connectivity

📱 Mobile App Features

What You Can Do On Your Phone

💬 AI Chat Interface

Ask Copilot anything: "Explain this function", "Add unit tests", "Optimize this code"
Full @workspace context - AI knows your entire project
Switch between AI models (GPT-4o, Claude, etc.)
Conversations sync automatically with VS Code

📁 Complete File Management

Browse your entire VS Code workspace
Open, read, and edit files directly on mobile
Navigate project structure with familiar folder tree
Quick file search and filtering

⚙️ Profile Management

Save multiple workspace connections
Quick switching between different projects
Automatic reconnection to saved profiles
Works across any network (home, office, mobile data)

🔄 Real-Time Synchronization

See VS Code changes instantly on mobile
Mobile edits appear in VS Code immediately
Chat conversations sync every 5 seconds
Manual sync button for instant updates

Premium Features (Mobile App v1.0.1+)

🎁 1-Day Free Trial: Automatic trial subscription created on first authentication (updated from 7-day trial)
💎 Premium Monthly ($9.99): Unlimited AI conversations and full feature access
🏆 Premium Annual ($99.99): All features with 17% savings
🔐 Subscription Authentication: Database-backed subscription verification integrated with VS Code extension
🏪 Google Play Store: Live on Google Play Store with active subscription processing

⚙️ Requirements

VS Code Setup

VS Code: Version 1.80 or later
GitHub Copilot Extension: Must be installed and authenticated
Active Workspace: Open project/folder in VS Code
Internet Connection: Required for mobile pairing and AI features

GitHub Copilot

Active Subscription: GitHub Copilot Individual, Business, or Enterprise
Authentication: Must be signed in to GitHub Copilot in VS Code
Supported Models: GPT-4o, Claude 3.5 Sonnet, and other available models

Mobile Device

VSCoder Mobile App: Download from Google Play Store (Android) or App Store (iOS) - VSCoder Copilot v1.0.1+ live on Google Play
App Package: com.emirbaycan.vscodercopilot (Android package identifier)
Internet Connection: WiFi or mobile data for device pairing
Operating System: Android 8.0+ or iOS 12.0+

💡 Note: Both devices need internet access for initial pairing, but they don't need to be on the same network!

🔧 Settings & Configuration

VSCoder works out of the box, but you can customize these settings:

Basic Settings

vscoder.port: Server port (default: 8080)
vscoder.autoStart: Auto-start server when VS Code opens (default: true)
vscoder.showMobileGuidance: Show helpful tips for mobile setup (default: true)

Advanced Settings

vscoder.discoveryApiUrl: Cloud service URL (default: production service)
vscoder.deviceToken: Device authentication token (auto-generated)
vscoder.pairingCode: Current pairing code (auto-refreshed every 10 minutes)
vscoder.enableRateLimitHandling: Enhanced rate limit protection (default: true)
vscoder.heartbeatInterval: Keep-alive interval in minutes (default: 10)

API Communication

vscoder.api.pollingInterval: How often to check for mobile messages (default: 3 seconds)
vscoder.api.timeout: Request timeout in milliseconds (default: 10 seconds)

🔧 To change settings: Go to VS Code Settings (Ctrl+,) and search for "vscoder"

Configuration Options Explained

vscoder.discoveryApiUrl: The cloud discovery service endpoint that enables cross-network device pairing. Uses production service by default.

vscoder.websiteUrl: The main website URL where the React application is hosted. Used for browser-based interactions and provides API proxy functionality.

vscoder.deviceToken: Authentication token automatically generated and managed by the subscription-based Discovery API. Tokens are database-backed and persist across server restarts for reliable authentication.

vscoder.pairingCode: Auto-generated 6-digit codes that expire every 10 minutes for security. Used for device pairing and subscription creation during authentication flow.

vscoder.api.url: Discovery API server URL for mobile app communication via message broker (same as discoveryApiUrl for consistency).

vscoder.api.pollingInterval: How often the extension polls for messages from mobile apps via Discovery API (in milliseconds).

vscoder.api.timeout: Maximum time to wait for API responses before timing out (in milliseconds).

Environment Variables

For development or custom deployments:

VSCODER_API_URL=https://api.vscodercopilot.com.tr
VSCODER_WEBSITE_URL=https://vscodercopilot.com.tr
VSCODER_WEBSOCKET_URL=wss://api.vscodercopilot.com.tr/ws

Quick Start

Prerequisites

VS Code 1.74.0 or later
Node.js 16.x or later
GitHub Copilot Extension installed and authenticated
Active Workspace with project files

Option 1: Automatic Pairing (Recommended)

Install Dependencies: npm install
Compile Extension: npm run compile
Launch Development: Press F5 to open Extension Development Host
Start Server: Run "VSCoder: Start VSCoder Server" command
Get Pairing Code: Run "VSCoder: Show Pairing Code" command (or check status bar)
Connect Mobile: Use 6-digit code in VSCoder mobile app to auto-connect across networks
Test Integration: Run "VSCoder: Test VSCoder Copilot Bridge"

📡 Cloud Discovery: The extension now uses the production discovery service at api.vscodercopilot.com.tr by default, enabling device pairing across different networks and locations.

Option 2: Manual Setup (Local Network Only)

Install Dependencies: npm install
Compile Extension: npm run compile
Launch Development: Press F5 to open Extension Development Host
Start Server: Run "VSCoder: Start VSCoder Server" command
Test Integration: Run "VSCoder: Test VSCoder Copilot Bridge"
Check Logs: View "VSCoder - Copilot Bridge" output channel
Configure Mobile: Manually set server IP/port in mobile app (local network only)

⚠️ Note: Manual setup only works for devices on the same local network. For cross-network connections, use the automatic pairing option.

Installation from VS Code Marketplace

Install Extension: Search for "VSCoder Copilot" in VS Code Extensions marketplace
Restart VS Code: Ensure proper extension activation
Verify Installation: Run "VSCoder: VSCoder Status" to check extension health
Start Server: Use "VSCoder: Start VSCoder Server" command to begin

✅ Production Ready: Version 1.2.2+ includes all dependencies and is fully marketplace compatible.

AI Integration Requirements

✅ GitHub Copilot Extension installed and authenticated
✅ Active Workspace with project files
✅ Model Access to GPT-4o, Claude, or other supported models

🔍 How It Works (Behind the Scenes)

Don't worry - this all happens automatically! This section is just for those curious about the technology.

Simple Connection Flow

Your Phone                VSCoder Cloud              Your VS Code
    📱                         ☁️                        💻
    │                          │                         │
    │ 1. Enter 6-digit code    │                         │
    ├─────────────────────────►│                         │
    │                          │ 2. Find VS Code        │
    │                          ├────────────────────────►│
    │                          │ 3. Return connection    │
    │                          │◄────────────────────────┤
    │ 4. Direct connection     │                         │
    │◄─────────────────────────┼────────────────────────►│
    │    🔐 Secure tunnel      │                         │

What Happens When You Pair

VS Code registers with our secure cloud service
You get a 6-digit code that's unique to your VS Code instance
Mobile app uses code to securely find your VS Code
Direct connection established - your code never goes through our servers
AI chat and file access work directly between your devices

Security & Privacy

Your code stays private: Only travels between your devices
Encrypted communication: All data is encrypted end-to-end
No data storage: We don't store your code or conversations
Temporary codes: Pairing codes expire every 10 minutes
Local control: You can stop the server anytime

Network Magic

The Cool Part: Your devices don't need to be on the same WiFi!

Home WiFi + Mobile Data: ✅ Works perfectly
Office network + Personal phone: ✅ No problem
Coffee shop + Hotel WiFi: ✅ Connects seamlessly
Different countries: ✅ Works globally

This is possible because our cloud service acts as a secure "introduction service" - it helps your devices find each other, then gets out of the way.

Note: Message broker endpoints require authentication token. Mobile apps and VS Code extension use these for cross-network message passing.

Main Website Integration

The main website at https://vscodercopilot.com.tr provides:

Project Information: Documentation, guides, and getting started resources
API Health Proxy: /health endpoint proxies to the backend API for status checks
API Gateway: /api/* endpoints proxy to the Discovery API backend
Resource Links: Download links for mobile apps and development tools

The website serves as the primary entry point for users while the API subdomain handles all backend operations.

Usage Examples

Check System Health

# Main website health (proxies to API backend)
curl https://vscodercopilot.com.tr/health

# Direct API health check
curl https://api.vscodercopilot.com.tr/health

Test Website API Proxy

# Test API endpoints through main website proxy
curl https://vscodercopilot.com.tr/api/v1/health

# Test authentication through website proxy
curl -X POST https://vscodercopilot.com.tr/api/v1/auth/token \
  -H "Content-Type: application/json" \
  -d '{"device_info": {"name": "test", "platform": "vscode", "version": "1.0.0"}}'

Get Message Queue Status (for a pairing code)

# Requires authentication token
curl "https://api.vscodercopilot.com.tr/api/v1/messages/ABC123/status" \
  -H "Authorization: Bearer YOUR_TOKEN"

Get Messages for Device (for debugging)

# Get messages for VS Code (receiver=vscode gets messages from mobile)
curl "https://api.vscodercopilot.com.tr/api/v1/messages/ABC123/vscode" \
  -H "Authorization: Bearer YOUR_TOKEN"

# Get messages for Mobile (receiver=mobile gets messages from VS Code)  
curl "https://api.vscodercopilot.com.tr/api/v1/messages/ABC123/mobile" \
  -H "Authorization: Bearer YOUR_TOKEN"

WebSocket Communication (Primary API)

// Connect to Discovery API WebSocket for real-time communication
const ws = new WebSocket('wss://api.vscodercopilot.com.tr/api/v1/messages/ws');

// Send AI prompt via message broker (can also use main website proxy)
const sendMessage = {
  pairing_code: "ABC123",
  sender: "mobile", // or "vscode"
  message: {
    type: "copilot_request",
    content: "Create a React component for user authentication",
    data: {
      agentMode: "autonomous"
    }
  }
};

// Send via Discovery API directly
fetch('https://api.vscodercopilot.com.tr/api/v1/messages/send', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_TOKEN'
  },
  body: JSON.stringify(sendMessage)
});

// Or send via main website proxy
fetch('https://vscodercopilot.com.tr/api/v1/messages/send', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_TOKEN'
  },
  body: JSON.stringify(sendMessage)
});

Workspace & File Operations

Mobile apps can send command messages through the Discovery API message broker to control VS Code:

📂 Workspace Commands

// Get workspace information
{
  pairing_code: "ABC123",
  sender: "mobile",
  message: {
    type: "command",
    content: "get_workspace_info"
  }
}

// List files in directory
{
  pairing_code: "ABC123", 
  sender: "mobile",
  message: {
    type: "command",
    content: "list_files",
    data: { path: "src" } // Optional: default is root
  }
}

📄 File Commands

// Read file content
{
  pairing_code: "ABC123",
  sender: "mobile", 
  message: {
    type: "command",
    content: "read_file",
    data: { path: "src/App.tsx" }
  }
}

// Write file content
{
  pairing_code: "ABC123",
  sender: "mobile",
  message: {
    type: "command", 
    content: "write_file",
    data: { 
      path: "src/NewComponent.tsx",
      content: "import React from 'react';\n\nexport const NewComponent = () => {\n  return <div>Hello World</div>;\n};"
    }
  }
}

// Open file in VS Code editor
{
  pairing_code: "ABC123",
  sender: "mobile",
  message: {
    type: "command",
    content: "open_file", 
    data: { path: "src/App.tsx" }
  }
}

🎯 Editor Commands

// Get active file information
{
  pairing_code: "ABC123",
  sender: "mobile",
  message: {
    type: "command",
    content: "get_active_file"
  }
}

// Focus VS Code editor
{
  pairing_code: "ABC123", 
  sender: "mobile",
  message: {
    type: "command",
    content: "focus_editor"
  }
}

⚡ System Commands

// Run terminal command
{
  pairing_code: "ABC123",
  sender: "mobile",
  message: {
    type: "command", 
    content: "run_terminal",
    data: { command: "npm install react" }
  }
}

// Execute VS Code command
{
  pairing_code: "ABC123",
  sender: "mobile", 
  message: {
    type: "command",
    content: "run_vscode_command",
    data: { 
      command: "workbench.action.files.save",
      args: [] // Optional arguments
    }
  }
}

🤖 AI & Copilot Commands

// Start AI chat session
{
  pairing_code: "ABC123",
  sender: "mobile",
  message: {
    type: "command",
    content: "copilot_chat", 
    data: {
      prompt: "Create a login form component with TypeScript",
      agentMode: "autonomous" // or "interactive", "code-review", etc.
    }
  }
}

// Add file to AI chat context
{
  pairing_code: "ABC123",
  sender: "mobile",
  message: {
    type: "command",
    content: "copilot_add_file_to_chat",
    data: { filePath: "src/App.tsx" }
  }
}

// Accept AI-generated edits
{
  pairing_code: "ABC123", 
  sender: "mobile",
  message: {
    type: "command",
    content: "copilot_accept_edits"
  }
}

// Reject AI-generated edits  
{
  pairing_code: "ABC123",
  sender: "mobile", 
  message: {
    type: "command",
    content: "copilot_reject_edits"
  }
}

// Get available AI models
{
  pairing_code: "ABC123",
  sender: "mobile",
  message: {
    type: "command",
    content: "copilot_get_models"
  }
}

// Change AI model
{
  pairing_code: "ABC123",
  sender: "mobile",
  message: {
    type: "command", 
    content: "copilot_change_model",
    data: { modelName: "gpt-4o" }
  }
}

Complete Command Reference

Command	Description	Required Data	Response
`get_workspace_info`	Get workspace folders and active file	-	`{workspace_folders, active_text_editor, language}`
`list_files`	List files in directory	`{path}`	`[{name, type, path}]`
`read_file`	Read file content	`{path}`	`{path, content, size}`
`write_file`	Write content to file	`{path, content}`	`{path, size, success}`
`open_file`	Open file in editor	`{path}`	`{success, message, path}`
`get_active_file`	Get active editor info	-	`{activeFile: {path, fileName, language, lineCount, isDirty, cursorPosition}}`
`focus_editor`	Focus VS Code editor	-	`{success, message}`
`run_terminal`	Execute terminal command	`{command}`	`{success, command, stdout, stderr, exit_code}`
`run_vscode_command`	Execute VS Code command	`{command, args?}`	`{success, result, command, message}`
`copilot_chat`	Start AI conversation	`{prompt, agentMode?}`	`{success, copilot_response}`
`copilot_add_file_to_chat`	Add file to AI context	`{filePath}`	`{success, message, filePath}`
`copilot_accept_edits`	Accept AI changes	-	`{success, message}`
`copilot_reject_edits`	Reject AI changes	-	`{success, message}`
`copilot_get_models`	List available AI models	-	`{success, models: []}`
`copilot_change_model`	Switch AI model	`{modelName}`	`{success, currentModel}`

Get Pairing Code

# Note: Pairing codes are managed internally by the extension
# Use VS Code command: "VSCoder: Show Pairing Code"
# Health check can be done via discovery service
curl https://api.vscodercopilot.com.tr/health

Check Discovery Status

# Check main website health (includes backend status)
curl https://vscodercopilot.com.tr/health

# Check discovery service health directly
curl https://api.vscodercopilot.com.tr/health

# Test discovery service authentication via website proxy
curl -X POST https://vscodercopilot.com.tr/api/v1/auth/token \
  -H "Content-Type: application/json" \
  -d '{"device_info": {"name": "test", "platform": "vscode", "version": "1.0.0"}}'

# Test discovery service authentication directly
curl -X POST https://api.vscodercopilot.com.tr/api/v1/auth/token \
  -H "Content-Type: application/json" \
  -d '{"device_info": {"name": "test", "platform": "vscode", "version": "1.0.0"}}'

# Test message broker endpoints (requires authentication token)
curl "https://api.vscodercopilot.com.tr/api/v1/messages/ABC123/status" \
  -H "Authorization: Bearer YOUR_TOKEN"

# Or via website proxy
curl "https://vscodercopilot.com.tr/api/v1/messages/ABC123/status" \
  -H "Authorization: Bearer YOUR_TOKEN"

WebSocket-First Architecture

The VSCoder extension uses a WebSocket-first approach for real-time communication:

Message Flow Architecture

Mobile App → Discovery API Message Broker → VS Code Extension
     ↓                    ↓                          ↓
Send Command → Queue Message by Pairing Code → WebSocket Notification
     ↑                    ↑                          ↓
Get Response ← Return Queued Result ← Process & Send Response

Key Features

Real-time Communication: WebSocket connection provides instant command/response flow
Message Broker Integration: Discovery API acts as secure message broker between devices
Session Management: Advanced session tracking with automatic cleanup
Progress Updates: Real-time progress callbacks from CopilotBridge to mobile apps
Auto-Reconnection: Smart reconnection logic with exponential backoff
Message Deduplication: Multi-layer duplicate prevention with content hashing

WebSocket Benefits

⚡ Instant Updates: Real-time progress updates during AI operations
🔄 Bidirectional: Full duplex communication for commands and responses
🛡️ Secure: Authenticated WebSocket connections with token validation
🌐 Cross-Network: Works across different networks via Discovery API
📱 Mobile-Optimized: Efficient for mobile app real-time requirements

WebSocket Events & Real-Time Communication

Real-time bidirectional communication for mobile apps with unlimited continuous monitoring:

Connection Events

connected: Server connection confirmation with welcome message
WebSocket Reconnection: Automatic reconnection with 3-second retry intervals

Unlimited Monitoring System

new_response: Real-time Copilot responses detected and captured immediately
- Limitless Duration: Monitoring runs forever until VS Code is closed
- Background Processing: Continuous monitoring without timeout restrictions
- Instant Detection: New messages appear immediately when generated
- Clean Response Flow: Only actual AI responses are sent to mobile app

File & Response Events

fileChanged: Live file update notifications with file path and content
copilotResponse: Final Copilot response data with complete results (legacy)

New Response Message Format

{
  "type": "copilotProgress",
  "updateType": "new_response",
  "data": {
    "message": "New Copilot response detected",
    "responseLength": 1247,
    "responseContent": "Here is the actual AI response content...",
    "fullResponse": "Complete response text",
    "checkNumber": 42
  },
  "timestamp": "2025-08-26T10:30:45.123Z"
}

WebSocket Integration Benefits

Never Miss Responses: Unlimited monitoring ensures every Copilot message is captured
Clean Chat Experience: Only AI responses shown, no progress message clutter
Instant Updates: Messages appear immediately when Copilot generates content
Background Processing: Monitoring doesn't interfere with VS Code or user interactions
Resource Efficient: Smart conversation tracking prevents duplicate detection

Mobile Development Workflow

Automatic Pairing Workflow (Recommended)

🚀 Start Server: Launch VSCoder server in VS Code
� Auto-Register: Server automatically registers with cloud discovery service
�🔐 Get Code: Check status bar or run "VSCoder: Show Pairing Code"
📱 Mobile Pairing: Enter 6-digit code in VSCoder mobile app from anywhere
✅ Auto Connect: Connection profile created automatically across networks
� Add Files to Chat: Attach workspace files to AI conversation for context-aware analysis
💬 Send Prompts: Use natural language to describe coding tasks and requirements
🤖 AI Generation: GitHub Copilot generates code using full workspace context and attached files
✅ Review & Apply: Accept, reject, undo, or modify AI-generated changes with granular control
🔄 Iterate & Refine: Continue the conversation with persistent context and iterative improvements

🌐 Cross-Network Support: Automatic pairing works across different networks, office/home connections, and mobile data.

Manual Connection Workflow (Local Network Only)

🚀 Start Server: Launch VSCoder server in VS Code
📱 Connect Mobile: Mobile app connects to discovered VS Code instance (cross-network via pairing)
🗂️ Browse Files: Explore project structure via WebSocket messages
💬 Send Prompts: Use natural language to describe coding tasks
🤖 AI Generation: GitHub Copilot generates code using workspace context
✅ Review & Apply: Accept or reject AI-generated changes
🔄 Iterate: Continue the conversation for refinements

⚠️ Network Limitation: Even manual setup now uses the discovery service for cross-network connectivity.

How VSCoder Works

Simple 3-Step Process

1️⃣ Install & Start VSCoder          2️⃣ Get Your Pairing Code          3️⃣ Connect from Anywhere
┌─────────────────────┐              ┌─────────────────────┐            ┌─────────────────────┐
│   💻 VS Code        │              │   🔐 6-Digit Code   │            │   📱 Mobile App     │
│                     │              │                     │            │                     │
│ ✅ Install Extension │              │  Status Bar: 123456 │            │ ✅ Enter Code: 123456│
│ ✅ Start Server     │   ────────►  │                     │  ────────► │ ✅ Auto-Connect     │
│ ✅ Auto-Register    │              │ 🌐 Works Globally   │            │ ✅ Start Coding     │
│                     │              │                     │            │                     │
└─────────────────────┘              └─────────────────────┘            └─────────────────────┘

What Makes VSCoder Special

🌍 Works Everywhere

Connect from different networks (home, office, coffee shop)
No complex setup or port forwarding needed
Secure cloud service handles the connection

🤖 AI-Powered Mobile Coding

Full GitHub Copilot integration on your phone
Natural language prompts: "Create a login component"
Real-time code generation and file management

📱 Professional Mobile Experience

Browse and edit your VS Code workspace files
Real-time sync with your desktop
Work on the go with full project context

🔐 Enterprise Security

6-digit pairing codes expire every 10 minutes
Encrypted communication end-to-end
Your code never leaves your devices

Communication Flow

Discovery Registration: Extension registers with cloud discovery service on startup
Pairing Code Generation: 6-digit codes generated and shared via discovery service
Mobile Connection: Mobile app uses pairing code to discover VS Code instance
IP:Port Discovery: Discovery service provides actual VS Code server IP and port
Direct WebSocket Connection: Mobile app connects directly to discovered VS Code extension
Message-Based API: All operations (file access, AI prompts, workspace management) via WebSocket messages

WebSocket Communication Architecture

The extension uses a WebSocket-first approach with Discovery API integration:

┌─────────────────┐    WebSocket (Primary)    ┌──────────────────┐
│   Mobile App    │ ◄────────────────────────► │   Discovery API  │
│                 │                           │ Message Broker   │
└─────────────────┘                           └──────────────────┘
                                                        │
                                                        │ WebSocket + Auth
                                                        ▼
                                              ┌──────────────────┐
                                              │   VS Code Ext    │
                                              │                  │
                                              │ • Progress Updates│
                                              │ • Command Handling│
                                              │ • Real-time Sync │
                                              └──────────────────┘

Message Flow & Session Management

WebSocket Primary: Real-time bidirectional communication
Message Deduplication: Advanced duplicate prevention with content hashing
Session Management: Request-based session tracking with automatic reset
Message Pool: Debugging and monitoring system with automatic cleanup
Progress Callbacks: Real-time progress updates from CopilotBridge to mobile app
Auto-Reconnection: Smart reconnection logic for unstable connections

Security Features

Database-Backed Authentication: Persistent token validation using subscription-based architecture
Bearer Token Authentication: 64-character hex tokens with automatic trial subscription creation
Subscription-Based Access Control: 1-day trial period with automatic premium upgrade options
WebSocket Authentication: Secure token-based WebSocket connections with real-time validation
Cross-Network Security: End-to-end encrypted communication through Discovery API
Workspace Isolation: File access restricted to current workspace only
Rate Limiting: Protection against abuse with configurable limits
HTTPS/WSS: Encrypted communication between all components
Cross-Network NAT: Secure tunneling through discovery service

🔧 Recent Updates & Improvements

Version 1.2.3 (Latest - September 2025)

🛠️ Stability & Reliability Enhancements: Major improvements to extension stability and user experience

✅ GitHub Copilot Extension Reload: Added reloadCopilot() functionality to fix memory issues and extension crashes
✅ Mobile App Button Integration: Connected mobile app reload button to VS Code extension reload functionality
✅ New Chat Session Fix: Resolved broken new chat button that was causing WebSocket connection issues
✅ Production Logging Cleanup: Removed verbose console logging for better production performance
✅ Enhanced Error Handling: Improved error handling and recovery mechanisms for extension operations
✅ Version Synchronization: Updated mobile app version to 1.0.3 across all configuration files

🔄 Code Quality & Performance:

Better function naming and code organization for improved maintainability
Enhanced state management without unnecessary WebSocket resets
Optimized memory usage and reduced logging overhead
Improved connection stability and graceful recovery mechanisms

Version 1.2.2 (Previous)

🚀 Mobile App Integration Enhancements: Optimized integration with VSCoder Copilot mobile app v1.0.1

✅ Enhanced Mobile Pairing: Improved reliability for 6-digit pairing code generation and validation
✅ Subscription Synchronization: Better synchronization with mobile app subscription states (1-day trial updates)
✅ Connection Stability: Enhanced WebSocket connection stability for mobile app communication
✅ Error Recovery: Improved error handling for mobile app connection issues and automatic reconnection
✅ Performance Optimization: Reduced memory usage and improved response times for mobile interactions
✅ Production Readiness: Optimizations for live Google Play Store mobile app deployment

🔐 Enhanced Security & Authentication:

Updated authentication flow for compatibility with mobile app v1.0.1 subscription model
Enhanced token validation for better mobile app authentication experience
Improved security measures for cross-network device pairing
Better handling of subscription trial periods and premium feature access

🛠️ Developer Experience Improvements:

Enhanced diagnostic commands for mobile app troubleshooting
Improved status indicators for mobile app connection states
Better error messages and guidance for mobile pairing issues
Enhanced logging and debugging capabilities for mobile integration

Version 1.2.0-1.2.1 (Previous)

🏗️ Enhanced WebSocket Architecture: Complete WebSocket-first communication with Discovery API

✅ Real-time Message Broker: WebSocket connection to Discovery API for instant command/response flow
✅ Advanced Session Management: Request-based session tracking with automatic cleanup and memory leak prevention
✅ Message Deduplication: Multi-layer duplicate prevention with content hashing and sequence tracking
✅ Progress Callback System: Real-time progress updates from CopilotBridge routed to mobile apps
✅ Auto-Reconnection Logic: Smart reconnection with exponential backoff for network stability
✅ Force Reconnect Capability: Page-refresh-like reconnection to resolve mobile navigation issues

🔐 Enhanced Authentication & Security:

Database-backed device authentication with persistent token storage
Automatic trial subscription creation (1-day trial, then premium upgrade)
Subscription-based access control aligned with business model
Bearer token management with database validation and persistence
Secure WebSocket connections with subscription-verified credentials
Enhanced rate limiting and subscription-based usage tracking

⚡ Performance & Reliability Improvements:

Enhanced WebSocket-first communication with Discovery API
Centralized authentication through DiscoveryService
Advanced message deduplication and session management
Real-time progress updates through WebSocket callbacks
Reduced redundant token generation
Improved error handling and diagnostics
Enhanced connection stability and reconnection logic
Force reconnect capability for mobile app navigation issues

🛠️ Developer Experience:

Enhanced troubleshooting commands and diagnostics
Comprehensive API connection testing commands
Advanced status bar indicators with connection status
Real-time progress monitoring with unlimited chat monitoring
Message pool system for debugging and monitoring
Session management with automatic cleanup
Detailed diagnostic information and health checks
Production-ready marketplace packaging (v1.2.2+)

Technical Architecture

Database-Backed Authentication System

The extension uses a robust database-backed authentication system that provides persistent token management and subscription-based access control:

Authentication Flow

Device Registration: Unique device tokens generated and stored in database
Subscription Validation: Real-time verification against subscription records
Token Persistence: Authentication state survives server restarts
Trial Management: Automatic 1-day trial creation for new devices

Database Schema

Device Table: device_token, user_info, subscription links
Subscription Table: trial_ends_at, expires_at, product_id, platform_receipt_id
Feature Access: Real-time subscription status checking

WebSocket Security

Bearer token authentication for all WebSocket connections
Automatic credential refresh and reconnection
Secure discovery service integration
Real-time subscription status validation

API Integration Points

The extension integrates with the VSCoder API through these endpoints:

POST /api/v1/auth/token - Device authentication
GET /api/v1/auth/status - Subscription verification
WebSocket /api/v1/chat/ws - Real-time communication
Discovery Service - Automatic server detection

Subscription-Based Access Control

All extension features require active subscription validation:

Trial Period: 1-day automatic trial for new users
Premium Features: Monthly ($9.99) or Annual ($99.99) subscriptions
Real-Time Validation: Continuous subscription status checking
Graceful Degradation: Clear messaging when subscription expires

Supported AI Models

The extension automatically detects available models through VS Code's Language Model API:

GPT Models: gpt-4o, gpt-4o-mini, gpt-4.1, gpt-5
Claude Models: claude-3.5-sonnet, claude-3.7-sonnet
O Models: o3, o4-mini
Custom Models: Any models available through GitHub Copilot

🔧 Mobile App Troubleshooting (Updated)

New Troubleshooting Commands

Use the built-in troubleshooter:

Ctrl+Shift+P → "VSCoder: Troubleshoot Mobile App Connection" - Complete mobile connection diagnostics
Ctrl+Shift+P → "VSCoder: Check API Communication Status" - Discovery API communication status
Ctrl+Shift+P → "VSCoder: Test API Connection" - Test Discovery API connectivity
Ctrl+Shift+P → "VSCoder: Send Test Message to Mobile App" - Send test message through message broker

These commands provide:

✅ Complete system diagnostics
⚠️ Issue detection and guidance
📋 Copy diagnostics to clipboard
🔧 One-click fixes for common problems

Common Mobile Connection Issues

❌ Getting 429 "Too Many Requests" Errors?

This is expected behavior! The mobile app should NOT connect directly to:

http://your-ip:8080/workspace ❌
http://your-ip:8080/files ❌

Correct connection flow:

Use pairing code in mobile app ✅
App connects to discovery service ✅
Discovery service provides VS Code connection details ✅
Secure connection established ✅

Rate Limiting Details:

Discovery service: 60 requests/minute per IP (increased from 10)
Mobile apps should use pairing codes for connection
Direct API calls are limited for security

❌ No Pairing Code Available?

Run "Generate New Pairing Code"
Ensure VS Code server is running
Check discovery service registration

❌ Discovery Service Not Registered?

Run "Test VSCoder Discovery Service"
Check internet connection
Verify discovery service URL in settings
Rate limits may cause temporary registration delays

❌ Mobile App Can't Find VS Code?

Ensure both devices have internet access
Use the 6-digit pairing code (not direct IP connection)
Check that VS Code extension is running
Try generating a new pairing code

Status Bar Indicators (Enhanced)

Icon	Status	Meaning	Action
`📱 123456 🔗`	✅ Ready (API Connected)	Pairing code available, registered, API connected	Click for options
`📱 123456 📱`	✅ Ready (Local Only)	Pairing code available, registered, local connection	Click for options
`📱 123456 ⚠️`	⚠️ Warning	Code available, not registered with discovery service	Click to troubleshoot
`📱 VSCoder ❌`	❌ Error	No pairing code available	Click to troubleshoot
`📱 VSCoder (Stopped)`	🔌 Offline	Server not running	Click to start

Discovery Service vs VS Code Server

Important: Mobile apps should distinguish between these services:

Discovery Service (https://api.vscodercopilot.com.tr):

🔍 Device registration and discovery
🔐 Pairing code validation
🛡️ Rate limiting for security (60 req/min)
🌐 Cross-network device finding

VS Code Server (Discovered via pairing):

📁 Actual workspace and file access
🤖 Copilot integration
🔄 Real-time collaboration
✏️ Code editing capabilities

API Updates for Mobile Apps

The VS Code server now provides helpful error messages when mobile apps connect to wrong endpoints:

// GET /workspace response (wrong endpoint)
{
  "error": "This is a VS Code server, not the discovery service",
  "message": "Use the discovery service with your pairing code",
  "guidance": {
    "step1": "Use the VSCoder mobile app pairing feature",
    "step2": "Enter your 6-digit pairing code", 
    "step3": "App will auto-discover this VS Code instance"
  }
}

Rate Limiting Best Practices

Mobile Apps: Always use pairing codes for initial connection
Direct Connections: Only after successful pairing
Error Handling: Implement exponential backoff for 429 errors
User Guidance: Show helpful messages for rate limit errors

🔧 Troubleshooting & Support

� Quick Fix Tool

Having issues? Use our built-in troubleshooter first:

Press Ctrl+Shift+P (Windows/Linux) or Cmd+Shift+P (Mac)
Type: VSCoder: Run VSCoder Diagnostics
Press Enter - Get instant diagnostics and fixes!

This tool will:

✅ Check your VS Code and GitHub Copilot setup
⚠️ Identify connection problems automatically
📋 Copy diagnostic info for support requests
🔧 Provide step-by-step solutions

Common Issues & Quick Fixes

📱 "No Pairing Code Available"

What you see: Status bar shows 📱 VSCoder ❌ or no code Quick fix:

Run VSCoder: Start VSCoder Server
Wait 10 seconds for registration
Run VSCoder: Show Pairing Code

🔌 "Server Won't Start"

What you see: Error messages when starting server Quick fix:

Check if port 8080 is busy: Change vscoder.port to 8081 in settings
Restart VS Code completely
Try VSCoder: Start VSCoder Server again

🤖 "GitHub Copilot Not Working"

What you see: AI features don't work in mobile app Quick fix:

In VS Code: Ctrl+Shift+P → GitHub Copilot: Sign Out
Sign back in: Ctrl+Shift+P → GitHub Copilot: Sign In
Test: Try asking Copilot a question in VS Code
Restart: VSCoder: Start VSCoder Server

📱 "Mobile App Can't Connect"

What you see: Connection timeouts or authentication errors Quick fix:

Check if VS Code server is running: Look for 📱 123456 in status bar
Get fresh pairing code: VSCoder: Show Pairing Code
Make sure both devices have internet access
Try VSCoder: Troubleshoot Mobile App Connection

🔐 "Device Validation Not Working"

What you see: Mobile app stays on "Connecting..." or shows validation errors Quick fix:

Check VS Code: Look for a notification at the bottom-right asking to approve the device
If no notification appears: Run VSCoder: Show Status to check WebSocket connection
Click "Approve" when the notification appears with device information
If notification was missed: Mobile app will timeout, try connecting again
Check notification details: Use "Details" button to see comprehensive device information
Check firewall: Ensure VS Code can receive WebSocket notifications

⏰ "Validation Request Expired"

What you see: "Validation request expired" error in mobile app Quick fix:

Wait 5 minutes for the previous request to fully expire
Get fresh pairing code: Run VSCoder: Show Pairing Code
Try connecting again - VS Code will show a new approval dialog
Approve quickly - Validation requests expire after 5 minutes for security

What you see: Mobile app says "connection failed" or "server not found" Quick fix:

Check internet: Both devices need internet (different networks OK!)
Fresh code: Run VSCoder: Generate New Pairing Code
Enter new code: Use the new 6-digit code in mobile app
Wait: Connection may take 30-60 seconds

What you see: After adding workspace with pairing code, navigating to chat page doesn't load messages/files until manual page refresh What's happening: WebSocket event listeners weren't properly re-established during navigation Quick fix:

Use Refresh Button: Tap the refresh button in the mobile app after navigation
Automatic Solution: The refresh button now mimics page refresh behavior
Force Reconnect: Mobile app uses forceReconnect() to reset WebSocket state completely
Works Like Magic: Should now work exactly like manual page refresh

Technical Details: The forceReconnect() method clears all WebSocket state, listeners, and message tracking, then re-establishes connection from scratch - exactly like a page refresh.

⏰ "Pairing Code Expired"

What you see: Code doesn't work in mobile app Why: Codes expire every 10 minutes for security Quick fix: Run VSCoder: Generate New Pairing Code

Pairing Code Problems

Cause: Codes expire every 10 minutes for security
Solution: Generate new code with "VSCoder: Generate New Pairing Code"
Check: Ensure VS Code server is running and registered with discovery service
Debug: Check "VSCoder - Discovery Service" output channel for errors
Mobile App Connection Issues

Use the Mobile Troubleshooter: Ctrl+Shift+P → "VSCoder: Troubleshoot Mobile App Connection"

❌ Getting 429 "Too Many Requests" Errors?

This is expected behavior! Mobile apps should NOT connect directly to:

http://your-ip:8080/workspace ❌
http://your-ip:8080/files ❌

Correct connection flow:

Use pairing code in VSCoder mobile app ✅
App connects to discovery service at `api.vscodercopilot.com.tr` ✅
Discovery service provides VS Code connection details ✅
Secure tunneled connection established ✅

Rate limiting details:

Discovery service: 60 requests/minute per IP
VS Code server: Direct connections only after pairing
Direct API calls without pairing are blocked for security

Discovery API Endpoints Used by Mobile Apps:

POST /api/v1/messages/send - Send messages through broker
GET /api/v1/messages/:pairingCode/:receiver - Get messages for device (vscode/mobile)
DELETE /api/v1/messages/:pairingCode/:receiver - Clear messages for device
GET /api/v1/messages/:pairingCode/status - Get message queue status
WebSocket /api/v1/messages/ws - Real-time communication

❌ Mobile App Can't Find VS Code?

Step-by-step diagnosis:

Check Extension Status: Ensure VS Code server is running
Verify Registration: Extension should be registered with discovery service
Get Fresh Code: Generate new pairing code if current one expired
Test Connectivity: Both devices need internet access (not same network)
Check Firewall: Ensure HTTPS connections are allowed

Common mistakes:

Trying to connect to local IP instead of using pairing code
Using expired pairing codes (>10 minutes old)
Extension not registered with discovery service
Network blocking HTTPS connections

❌ Discovery Service Not Responding?

Troubleshooting steps:

Test Cloud Service: curl https://api.vscodercopilot.com.tr/health
Check Configuration: Verify vscoder.api.url setting
Network Diagnostics: Test internet connectivity and DNS resolution
Firewall Check: Ensure HTTPS outbound connections allowed
Rate Limits: Wait if receiving 429 errors (temporary)

Advanced Troubleshooting

File Access Denied

Cause: Attempting to access files outside workspace
Solution: Ensure all file paths are within current workspace boundaries
Security: This is intentional - extension only accesses workspace files

Model Switching Issues

Cause: VS Code API limitations for programmatic model switching
Workaround: Model switching may open UI picker instead of direct switch
Expected: This is current VS Code behavior, not an extension bug

Performance Issues

Memory: Extension monitors Copilot continuously - this is normal
CPU: Background monitoring is lightweight and optimized
Network: WebSocket connections maintained for real-time updates

Debug Commands & API Testing

# Test discovery service health
curl https://api.vscodercopilot.com.tr/health

# Test discovery service authentication
curl -X POST https://api.vscodercopilot.com.tr/api/v1/auth/token \
  -H "Content-Type: application/json" \
  -d '{"device_info": {"name": "test-device", "platform": "vscode", "version": "1.0.0"}}'

# Test message broker (requires authentication token)
curl -X POST https://api.vscodercopilot.com.tr/api/v1/messages/send \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"pairing_code": "ABC123", "sender": "vscode", "message": {"type": "test", "content": "Hello"}}'

# Get messages for a pairing code (requires authentication)
curl "https://api.vscodercopilot.com.tr/api/v1/messages/ABC123/mobile" \
  -H "Authorization: Bearer YOUR_TOKEN"

# Get message queue status
curl "https://api.vscodercopilot.com.tr/api/v1/messages/ABC123/status" \
  -H "Authorization: Bearer YOUR_TOKEN"

VS Code Command Testing

Run these via Ctrl+Shift+P in VS Code:

VSCoder: Run Diagnostics - Comprehensive system check
VSCoder: Test Discovery Service - Discovery service integration test
VSCoder: Test Copilot Bridge - AI integration verification
VSCoder: Troubleshoot Mobile App Connection - Mobile-specific diagnostics
VSCoder: Show Status - Quick status overview
VSCoder: Show Pairing Code - Display current pairing code
VSCoder: Check API Communication Status - Discovery API communication status
VSCoder: Test API Connection - Test Discovery API connectivity
VSCoder: Send Test Message to Mobile App - Send test message through message broker

Output Channels

Monitor these in VS Code Output panel:

VSCoder - Copilot Bridge: AI integration and command execution
VSCoder - Discovery Service: Discovery service communication and errors
VSCoder - Server: Local server startup and connection logs
VSCoder - WebSocket: Real-time communication debugging

Production Deployment

Default Configuration (Production Ready)

The extension connects to the production VSCoder Discovery Service by default:

{
  "vscoder.api.url": \"https://api.vscodercopilot.com.tr\",
  "vscoder.port": 8080,
  "vscoder.autoStart": true,
  "vscoder.deviceToken": "dev-token"
}

Production Benefits

🌐 Cross-Network Pairing: Connect devices across different networks and locations
☁️ Cloud Discovery: No local discovery service setup required
🔒 Secure HTTPS: End-to-end encrypted communication
📡 Global Access: Pair devices from anywhere with internet connectivity
🛡️ Enterprise Security: Rate limiting, authentication, and workspace isolation
⚡ High Availability: Production-grade infrastructure with monitoring

Custom Discovery Service

For enterprise deployments, configure a custom discovery service:

{
  "vscoder.api.url": "https://your-enterprise-discovery.com",
  "vscoder.deviceToken": "your-enterprise-token"
}

Marketplace Installation

Extension is production-ready with marketplace compatibility:

✅ All Dependencies Included: Express, WebSocket, and other libraries packaged (v1.2.2+)
✅ Modern VS Code API: Compatible with VS Code ^1.74.0+
✅ Proper Activation: Extension activates automatically on workspace open
✅ Error Handling: Comprehensive diagnostics and recovery mechanisms
✅ Security Compliant: Workspace-scoped access and secure communication

Development & Testing

Development Setup

# Clone repository
git clone https://github.com/emirbaycan/vscoder-copilot.git
cd vscoder-copilot/extension

# Install dependencies
npm install

# Compile TypeScript
npm run compile

# Watch for changes (development)
npm run watch

# Launch Extension Development Host
# Press F5 in VS Code

Running Tests

# Compile and run tests
npm test

# Test specific components
npm run test:unit
npm run test:integration

# Coverage report
npm run test:coverage

Extension Development

Code Changes: Edit TypeScript files in src/
Compile: Run npm run compile or use watch mode
Test: Press F5 to launch Extension Development Host
Debug: Use VS Code debugger with breakpoints
Package: Run vsce package to create .vsix file

Development Dependencies

{
  "dependencies": {
    "express": "^4.18.2",
    "ws": "^8.13.0"
  },
  "devDependencies": {
    "@types/express": "^5.0.3",
    "@types/node": "16.x",
    "@types/vscode": "^1.74.0",
    "@types/ws": "^8.5.4",
    "@types/mocha": "^10.0.6", 
    "@types/sinon": "^17.0.3",
    "mocha": "^10.2.0",
    "sinon": "^17.0.1",
    "typescript": "^4.9.4"
  }
}

Available Scripts

npm run compile          # Compile TypeScript
npm run watch           # Watch for changes
npm test               # Run all tests
npm run test:unit      # Run unit tests
npm run test:integration # Run integration tests
npm run package        # Package extension (.vsix)
npm run publish        # Publish to marketplace

API Testing

# Test VS Code extension server endpoints
npm run test:api

# Manual VS Code server testing (use discovered IP:port from pairing)
curl http://<vs-code-ip-port>/health
curl http://<vs-code-ip-port>/messages/status
curl "http://<vs-code-ip-port>/messages/acknowledge" \
  -X POST -H "Content-Type: application/json" \
  -d '{"clientId": "test", "sequenceNumber": 1}'

# Test Discovery API directly
curl https://api.vscodercopilot.com.tr/health
curl -X POST https://api.vscodercopilot.com.tr/api/v1/auth/token \
  -H "Content-Type: application/json" \
  -d '{"device_info": {"name": "test", "platform": "vscode", "version": "1.0.0"}}'

Debugging Tips

Output Channels: Monitor "VSCoder - *" channels for detailed logs
DevTools: Use "Developer: Toggle Developer Tools" for web debugging
Network: Monitor network requests in DevTools Network tab
WebSocket: Use WebSocket debugging tools for real-time communication
Copilot: Check GitHub Copilot extension logs for AI integration issues

Contributing Guidelines

Code Style: Follow TypeScript and ESLint conventions
Testing: Add tests for new features and bug fixes
Documentation: Update README and JSDoc comments
Commit Messages: Use conventional commit format
Pull Requests: Include description, testing steps, and breaking changes

Next Steps

This extension works with the VSCoder Copilot mobile app v1.0.1 which is now live on Google Play Store:

📱 Download from Google Play: Search "VSCoder Copilot" on Google Play Store or use package identifier com.emirbaycan.vscodercopilot
💬 Complete Chat Interface for natural language programming with GitHub Copilot
🔄 Real-Time Sync with VS Code workspace and automatic chat synchronization
🤖 AI-Powered Development with context-aware code generation and file management
🔗 6-Digit Pairing Codes for seamless cross-network device discovery and connection
📡 Production Cloud Service at vscodercopilot.com.tr for global device connectivity

Live Production System

VSCoder Mobile App v1.0.1: Live on Google Play Store with 1-day free trial and premium subscriptions
VSCoder Discovery API v2.0: Production Go-based service at api.vscodercopilot.com.tr
VSCoder Extension v1.2.2: This VS Code extension optimized for mobile app integration
Complete Ecosystem: End-to-end mobile development workflow with live production deployment

Contributing

Fork the repository at https://github.com/emirbaycan/vscoder-copilot
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request to the main repository

License

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

💡 Real-World Use Cases

🚗 Daily Commute Development

"I spend 45 minutes on the train each day. Now I use that time for code reviews and AI-assisted debugging."

Perfect for:

Reviewing pull requests on mobile
Getting AI explanations of complex code
Planning your coding tasks for the day
Asking Copilot architecture questions

☕ Coffee Shop Coding

"Working from a café but need to make a quick fix? No problem - my phone becomes my mobile development station."

Perfect for:

Emergency bug fixes from anywhere
Quick feature implementations
Responding to urgent code review comments
Testing ideas with AI assistance

🏠 Couch Coding Sessions

"Sometimes I get my best ideas while relaxing. Now I can prototype them immediately on my phone."

Perfect for:

Late-night coding inspiration
Weekend project exploration
Learning new concepts with AI help
Experimenting without setting up laptop

🏢 Meeting Room Quick Fixes

"During code reviews, I can make suggested changes immediately on my phone while still in the meeting."

Perfect for:

Live code demonstrations
Immediate bug fixes during discussions
Quick prototyping of ideas
Showing AI-generated solutions to team

🌍 Remote Work Flexibility

"Whether I'm working from home, office, or anywhere else, my mobile development setup follows me."

Perfect for:

Seamless workspace switching
Backup development environment
Working across different networks
Maintaining productivity anywhere

💭 The Bottom Line: VSCoder turns dead time into productive coding time. Your smartphone becomes a powerful development tool that works anywhere you have internet!

❓ Frequently Asked Questions

General Questions

Q: Do I need to pay for anything? A: The VS Code extension is completely free! The mobile app offers a 1-day free trial, then requires a premium subscription (Monthly $9.99 or Annual $99.99) for unlimited AI features.

Q: Does this work with my existing GitHub Copilot subscription? A: Yes! VSCoder uses your existing GitHub Copilot subscription. You just need Copilot installed and authenticated in VS Code.

Q: Is my code safe and private? A: Absolutely. Your code travels directly between your devices through encrypted connections. We don't store or see your code - our service just helps your devices find each other.

Q: What if I don't have the same WiFi network? A: That's the magic! VSCoder works across different networks. Your phone can be on mobile data while your computer is on office WiFi - no problem.

Setup Questions

Q: Why do I need a 6-digit code? A: The code is like a temporary password that helps your mobile app securely find your VS Code instance. Codes expire every 10 minutes for security.

Q: Can I use this with multiple projects? A: Yes! The mobile app can save multiple workspace profiles, and you can quickly switch between different VS Code instances.

Q: Do I need to configure firewall or network settings? A: Nope! VSCoder uses standard HTTPS connections that work through most networks and firewalls automatically.

Usage Questions

Q: Can multiple people connect to the same VS Code? A: Each pairing code works for one mobile device at a time. If you want team collaboration, each team member should use their own VS Code + mobile app.

Q: What happens if my internet connection is spotty? A: VSCoder automatically reconnects when your connection comes back. Your conversations and progress are preserved.

Q: Can I use this without GitHub Copilot? A: The mobile app can browse and edit files without Copilot, but you'll need an active Copilot subscription for AI features.

Technical Questions

Q: Which AI models does this support? A: All models available through your GitHub Copilot subscription - GPT-4o, Claude 3.5 Sonnet, and any future models GitHub adds.

Q: Does this slow down VS Code? A: No, the extension runs efficiently in the background and doesn't impact VS Code performance.

Q: Can I turn off the mobile connection? A: Yes! Use VSCoder: Stop VSCoder Server to disable mobile connectivity anytime.

Troubleshooting Questions

Q: My pairing code doesn't work - what's wrong? A: Codes expire every 10 minutes for security. Generate a fresh one with VSCoder: Generate New Pairing Code.

Q: The mobile app says "connection failed" - help! A: Run VSCoder: Run VSCoder Diagnostics in VS Code for instant troubleshooting. Most issues are fixed automatically.

Q: Can I use this behind a corporate firewall? A: VSCoder uses standard HTTPS connections that work through most corporate networks. If you have issues, ask your IT team to allow connections to *.vscodercopilot.com.tr.

🎉 Ready to Get Started?

Step 1: Install This Extension

Open VS Code Extensions (Ctrl+Shift+X)
Search: "VSCoder Copilot"
Click Install and you're ready!

Step 2: Download Mobile App

Android: Google Play Store
iOS: Apple App Store

Step 3: Start Coding on Mobile!

Follow the 2-minute setup guide above
Get your pairing code from VS Code
Enter code in mobile app
Start AI-powered mobile development!

🌟 What Developers Are Saying

"Game changer for my daily commute. I get so much code review work done on the train now!" - Sarah, Full Stack Developer

"Perfect for emergency fixes. Last week I fixed a production bug from a restaurant using just my phone." - Mike, DevOps Engineer

"The AI integration is seamless. It's like having GitHub Copilot in my pocket." - Alex, React Developer

"I love how it works across networks. Home WiFi, office network, mobile data - doesn't matter." - Jessica, Remote Developer

🔗 Links & Resources

🌐 Official Website: vscodercopilot.com.tr
📱 Mobile App Store Pages: Coming soon!
📧 Support: support@vscodercopilot.com.tr
💬 Community: GitHub Discussions
🐛 Bug Reports: GitHub Issues
📖 Documentation: Full Documentation

📄 License & Contributing

This project is open source under the MIT License. We welcome contributions!

🍴 Fork the repo: github.com/emirbaycan/vscoder-copilot
🐛 Report bugs: Use GitHub Issues for bug reports
💡 Feature requests: Share ideas in GitHub Discussions
🤝 Contribute: Pull requests are welcome!

🚀 Transform Your Mobile Device Into an AI-Powered Coding Companion

Install VSCoder Copilot Extension Now

Made with ❤️ for developers who code everywhere

VSCoder Copilot

Emir Baycan

🚀 VSCoder Copilot - AI-Powered Mobile Development

✨ What Makes VSCoder Special

🎯 Key Features

🚀 Quick Start (2 Minutes)

Step 1: Install Extension

Step 2: Start the Server

Step 3: Get Your Pairing Code

Step 4: Connect Mobile App

Step 5: Start AI-Powered Coding! 🎉

📋 Available Commands

📱 Mobile App Features

What You Can Do On Your Phone

Premium Features (Mobile App v1.0.1+)

⚙️ Requirements

VS Code Setup

GitHub Copilot

Mobile Device

🔧 Settings & Configuration

Basic Settings

Advanced Settings

API Communication

Configuration Options Explained

Environment Variables

Quick Start

Prerequisites

Option 1: Automatic Pairing (Recommended)

Option 2: Manual Setup (Local Network Only)

Installation from VS Code Marketplace

AI Integration Requirements

🔍 How It Works (Behind the Scenes)

Simple Connection Flow

What Happens When You Pair

Security & Privacy

Network Magic

Main Website Integration

Usage Examples

Check System Health

Test Website API Proxy

Get Message Queue Status (for a pairing code)

Get Messages for Device (for debugging)

WebSocket Communication (Primary API)

Workspace & File Operations

📂 Workspace Commands

📄 File Commands

🎯 Editor Commands

⚡ System Commands

🤖 AI & Copilot Commands

Complete Command Reference

Get Pairing Code

Check Discovery Status

WebSocket-First Architecture

Message Flow Architecture

Key Features

WebSocket Benefits

WebSocket Events & Real-Time Communication

Connection Events

Unlimited Monitoring System

File & Response Events

New Response Message Format

WebSocket Integration Benefits

Mobile Development Workflow

Automatic Pairing Workflow (Recommended)

Manual Connection Workflow (Local Network Only)

How VSCoder Works

Simple 3-Step Process

What Makes VSCoder Special

Communication Flow

WebSocket Communication Architecture

Message Flow & Session Management

Security Features

🔧 Recent Updates & Improvements

Version 1.2.3 (Latest - September 2025)

Version 1.2.2 (Previous)

Version 1.2.0-1.2.1 (Previous)

Technical Architecture

Database-Backed Authentication System

Authentication Flow

Database Schema