Google Jules MCP

A Model Context Protocol (MCP) server for automating Google Jules - the AI coding assistant. This MCP enables seamless integration with Jules for task creation, code review automation, repository management, and AI-powered development workflows.

Features

🎯 Task Management

• Create Tasks: Automatically create Jules tasks with repository and description
• Monitor Progress: Track task status and get real-time updates
• Approve Plans: Review and approve Jules execution plans
• Resume Tasks: Resume paused or interrupted tasks
• Bulk Operations: Create multiple tasks efficiently

🔧 Code Operations

• Code Analysis: Analyze code changes and diffs
• Branch Management: Handle repository branches and configurations
• Source Navigation: Browse and analyze source files
• Review Automation: Automate code review workflows

💬 Interactive Communication

• Send Messages: Send instructions and feedback to Jules
• Chat History: Track conversation history with Jules
• Context Extraction: Extract relevant context from task discussions

📊 Project Management

• Task Listing: List and filter tasks by status
• Progress Tracking: Monitor development progress across projects
• Data Persistence: Local storage of task data and history

🔐 Session Management (NEW!)

• Multiple Session Modes: Fresh, Chrome profile, cookies, persistent, and Browserbase
• Google Authentication: Seamless login with existing Google sessions
• Cookie Management: Extract, save, and restore authentication cookies
• Remote Browser Support: Use Browserbase for cloud deployments
• Cross-Platform: Works locally and in cloud environments

Available Tools

🔐 Session Management & Authentication

Session Modes

The MCP supports 5 different session management modes:

Configuration Options

🌐 Browserbase (Recommended for Smithery)

Perfect for remote deployments and cloud hosting:

SESSION_MODE=browserbase
BROWSERBASE_API_KEY=bb_live_g3i-b4WPFh__E3cErKE5rO-jWds  # Your API key
BROWSERBASE_PROJECT_ID=d718e85f-be7b-497d-9123-b1bbf798f1bb  # Your project ID
BROWSERBASE_SESSION_ID=                    # Optional: use existing session

🍪 Cookie Authentication (Best for Manual Setup)

Extract cookies from your browser and set them as environment variable:

SESSION_MODE=cookies
GOOGLE_AUTH_COOKIES="session_id=abc123; domain=.google.com; auth_token=xyz789; domain=.google.com"
COOKIES_PATH=~/.jules-mcp/cookies.json     # File to save/load cookies

🌍 Chrome Profile (Local Development)

Use your existing Chrome profile:

SESSION_MODE=chrome-profile
CHROME_USER_DATA_DIR=/Users/yourname/Library/Application Support/Google/Chrome/Default

💾 Persistent Browser Data

Save browser data to a specific directory:

SESSION_MODE=persistent
CHROME_USER_DATA_DIR=~/.jules-mcp/browser-data  # Custom browser data directory

How to Get Google Authentication Cookies

1. Log in to Jules: Visit https://jules.google.com and log in
2. Open Developer Tools: Press F12 or Cmd+Option+I
3. Go to Application/Storage tab
4. Find Cookies: Look for .google.com cookies
5. Copy Important Cookies: Look for cookies like:
   • session_id or sessionid
   • auth_token or authuser
   • SID, HSID, SSID
   • SAPISID, APISID

Format for environment variable:

GOOGLE_AUTH_COOKIES="cookie1=value1; domain=.google.com; cookie2=value2; domain=.google.com"

Environment Configuration

Create a .env file or set environment variables:

# Browser Configuration
HEADLESS=true              # Run browser in headless mode
TIMEOUT=30000              # Browser timeout in milliseconds
DEBUG=false                # Enable debug mode with screenshots

# Session Management
SESSION_MODE=browserbase   # fresh | chrome-profile | cookies | persistent | browserbase

# Browserbase Configuration (for remote/cloud deployments)
BROWSERBASE_API_KEY=your_api_key
BROWSERBASE_PROJECT_ID=your_project_id
BROWSERBASE_SESSION_ID=optional_existing_session

# Cookie Authentication
GOOGLE_AUTH_COOKIES="session_id=abc; domain=.google.com"
COOKIES_PATH=~/.jules-mcp/cookies.json

# Chrome Profile (local development)
CHROME_USER_DATA_DIR=/path/to/chrome/profile

# Data Storage
JULES_DATA_PATH=~/.jules-mcp/data.json  # Custom data storage path

MCP Resources

The server provides useful resources for context:

• jules://schemas/task - Complete task data model
• jules://current/active-tasks - Live list of active tasks
• jules://templates/common-tasks - Template examples for common development tasks

Common Task Templates

The MCP includes templates for common development scenarios:

• Bug Fix: "Fix the [specific issue] in [filename]. The problem is [description]."
• Feature Add: "Add [feature name] functionality to [location]. Requirements: [list requirements]."
• Refactor: "Refactor [component/function] to improve [performance/readability/maintainability]."
• Testing: "Add comprehensive tests for [component/function] covering [test cases]."
• Documentation: "Update documentation for [component] to include [new features/changes]."

Integration with Claude Code

Local Integration

{
  "mcpServers": {
    "google-jules-mcp": {
      "command": "node",
      "args": ["path/to/google-jules-mcp/dist/index.js"],
      "env": {
        "HEADLESS": "true",
        "SESSION_MODE": "cookies",
        "GOOGLE_AUTH_COOKIES": "your_cookies_here",
        "DEBUG": "false"
      }
    }
  }
}

Development

Project Structure

google-jules-mcp/
├── src/
│   └── index.ts          # Main MCP server implementation
├── docs/
│   └── referencerecordings/  # Browser automation references
├── scripts/
│   └── test-mcp.js       # Testing script
├── dist/                 # Compiled output
├── package.json
├── tsconfig.json
└── smithery.yaml         # MCP deployment config

Contributing

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests if applicable
5. Submit a pull request

Testing

# Run the test suite
npm test

# Build and test
npm run build && npm test

# Development mode with file watching
npm run dev

Architecture

The MCP follows established patterns:

• Browser Automation: Uses Playwright for reliable web automation
• Data Persistence: Local JSON storage for task tracking
• Error Handling: Comprehensive error handling with meaningful messages
• Resource Management: Proper browser lifecycle management
• Security: No credential storage, relies on browser session

Workflow Integration

This MCP is designed to integrate with development workflows:

1. Issue Tracking → Jules Tasks: Convert GitHub issues to Jules tasks
2. Code Review → Automation: Automate code review processes
3. CI/CD Integration: Trigger Jules tasks from deployment pipelines
4. Team Collaboration: Share Jules task management across teams

License

MIT License - see LICENSE file for details.

Acknowledgments

• Built with the Model Context Protocol SDK
• Inspired by the tusclasesparticulares-mcp implementation patterns
• Browser automation powered by Playwright

Note: This MCP requires access to Google Jules. Ensure you have appropriate permissions and access to the repositories you want to manage.

Installation

Prerequisites

• Node.js 18+
• TypeScript
• Git access to repositories you want to manage

Setup

# Clone the repository
git clone https://github.com/samihalawa/google-jules-mcp.git
cd google-jules-mcp

# Install dependencies
npm install

# Build the project
npm run build

# Test the installation
npm test

Usage Examples

1. Create a New Task

// Create a task to fix a bug
{
  "name": "jules_create_task",
  "arguments": {
    "description": "Fix the login authentication bug in the user dashboard. The issue occurs when users try to log in with special characters in their password.",
    "repository": "mycompany/webapp",
    "branch": "main"
  }
}

2. Monitor Task Progress

// Get task details and progress
{
  "name": "jules_get_task",
  "arguments": {
    "taskId": "9103172019911831130"
  }
}

3. Send Instructions to Jules

// Send additional context or instructions
{
  "name": "jules_send_message",
  "arguments": {
    "taskId": "9103172019911831130",
    "message": "Please also add unit tests for the authentication fix and ensure backward compatibility."
  }
}

4. Bulk Task Creation

// Create multiple tasks at once
{
  "name": "jules_bulk_create_tasks",
  "arguments": {
    "tasks": [
      {
        "description": "Add dark mode support to the UI",
        "repository": "mycompany/frontend",
        "branch": "feature/dark-mode"
      },
      {
        "description": "Optimize database queries for user search",
        "repository": "mycompany/backend",
        "branch": "performance/search"
      }
    ]
  }
}

5. List and Filter Tasks

// List active tasks
{
  "name": "jules_list_tasks",
  "arguments": {
    "status": "in_progress",
    "limit": 10
  }
}

6. Session Management Examples

Check Session Status

{
  "name": "jules_session_info",
  "arguments": {}
}

Get Current Cookies (for backup)

{
  "name": "jules_get_cookies",
  "arguments": {
    "format": "string"  // or "json"
  }
}

Set Authentication Cookies

{
  "name": "jules_set_cookies",
  "arguments": {
    "cookies": "session_id=abc123; domain=.google.com; auth_token=xyz789; domain=.google.com",
    "format": "string"
  }
}

🌐 Smithery Deployment

Deploy to Smithery.ai

The MCP is fully configured for Smithery deployment with comprehensive session management:

1. Fork/Clone this repository
2. Deploy to Smithery: Visit smithery.ai and connect your repo
3. Configure Session Management in Smithery settings:

Option A: Browserbase (Recommended)

SESSION_MODE=browserbase
BROWSERBASE_API_KEY=bb_live_g3i-b4WPFh__E3cErKE5rO-jWds
BROWSERBASE_PROJECT_ID=d718e85f-be7b-497d-9123-b1bbf798f1bb

Option B: Cookie Authentication

SESSION_MODE=cookies
GOOGLE_AUTH_COOKIES="session_id=abc123; domain=.google.com; auth_token=xyz789; domain=.google.com"

4. Access Remotely: Use your deployed MCP from any Claude Code instance

Benefits of Smithery + Browserbase

• ✅ No Local Browser: Runs entirely in the cloud
• ✅ Persistent Sessions: Maintain Google authentication across deployments
• ✅ Global Access: Use from anywhere with internet connection
• ✅ Auto-scaling: Handles multiple concurrent requests
• ✅ Zero Setup: No local dependencies or configuration needed

Troubleshooting

Common Issues

1. Browser Automation Fails

   • Ensure you have proper access to jules.google.com
   • Check if you're logged into your Google account
   • Try running with HEADLESS=false to see what's happening

2. Task Creation Fails

   • Verify repository names are correct (owner/repo-name format)
   • Ensure you have access to the specified repositories
   • Check that branches exist

3. Permission Errors

   • Make sure you have write access to the data storage path
   • Verify repository permissions in GitHub

Debug Mode

Enable debug mode for troubleshooting:

DEBUG=true HEADLESS=false npm start

This will:

• Show browser interactions visually
• Take screenshots on errors
• Provide detailed logging