Goosecode Server

A containerized VS Code server environment with integrated Goose AI coding agent. This project provides a ready-to-use Docker setup that combines VS Code Server with the Goose AI agent, allowing you to access a powerful coding environment through your browser.

Features

• Browser-Based Development: Access VS Code directly from your browser
• Goose AI Agent: Pre-installed and configured Goose AI Coding agent
• Shared Terminal Session: The same Goose session is visible in all browser windows
• Goose Terminal API: REST API for sending commands to the terminal and retrieving session logs
• Streaming Conversations: Real-time streaming of Goose AI conversations using Server-Sent Events (SSE)
• Material Design: Dark theme with Material icons for a beautiful coding experience
• Secure Environment: Password-protected VS Code Server instance
• Git Integration: Git pre-installed and ready for repository operations
• Persistent Configuration: Environment variables and configuration preserved between sessions (Unless workspace is deleted)

Quick Start

1. Clone this repository

   git clone https://github.com/PlatOps-AI/goosecode-server.git
   cd goosecode-server

2. Create or edit .env file with your OpenAI API key

   cp .env.example .env
   # Edit .env with your API key

3. Run the container

4. Access Goosecode Server

   • Open your browser and navigate to: http://localhost:8080
   • Default password: talktomegoose (can be changed in .env)
   • A shared terminal with Goose will start automatically

Using the run.sh Script

The run.sh script provides a convenient way to manage your Goosecode Server container. It handles building the image, starting/stopping the container, and passing environment variables.

Basic Usage

Advanced Options

You can pass environment variables and configuration options directly to the script:

./run.sh --openai-key=your_api_key_here --password=your_password --port=8888

Available Options

Environment Variables Priority

1. Command-line arguments (highest priority)
2. Variables from .env file
3. Default values (lowest priority)

Using Goose AI Assistant

Goosecode Server automatically starts a shared Goose AI terminal session when you launch the container. This means:

• The same Goose session is visible in all browser windows
• Multiple users can see and interact with the same conversation
• The session persists even when browser windows are closed

Accessing the Shared Goose Session

When you open VS Code in your browser:

1. A terminal with Goose AI should open automatically

2. If not, open a terminal in VS Code and run one of these commands:

   # Full interactive mode (default)
   ~/shared-goose.sh
   
   # View-only mode (can't type, just watch)
   ~/goose-view.sh

3. Each new terminal creates a unique session linked to the shared content

4. Start interacting with Goose by typing your questions or instructions

Using Environment Variables for Session IDs

You can specify a custom session ID using environment variables:

1. Set the GOOSE_SESSION_ID environment variable in your .env file or via the --goose-session flag:

   # In .env file
   GOOSE_SESSION_ID=my-project-session
   
   # Or when running the container
   ./run.sh --goose-session=my-project-session

2. To resume an existing session, set the GOOSE_RESUME_SESSION environment variable:

   # In .env file
   GOOSE_SESSION_ID=my-project-session
   GOOSE_RESUME_SESSION=true
   
   # Or when running the container
   ./run.sh --goose-session=my-project-session --resume-session

These variables allow you to maintain consistent session IDs across container restarts or share specific sessions with team members.

Goose Configuration

Goose is pre-configured with the following settings:

GOOSE_PROVIDER: openai
extensions:
  developer:
    enabled: true
    name: developer
    type: builtin
GOOSE_MODE: auto
GOOSE_MODEL: o3-mini-2025-01-31
OPENAI_BASE_PATH: v1/chat/completions
OPENAI_HOST: https://api.openai.com

To view your current configuration:

cat ~/.config/goose/config.yaml

To modify your configuration:

UI Customization

The VS Code Server instance comes pre-configured with:

• Dark Theme: Easy on the eyes for long coding sessions
• Material Icon Theme: Beautiful file and folder icons
• Material Product Icons: Enhanced VS Code UI icons
• Custom Colors: Optimized color scheme for code readability

Docker Container Management

Building the Container

docker build -t goosecode-server .

Running the Container Manually

docker run -d -p 8080:8080 -p 8000:8000 --name goosecode-server --env-file .env goosecode-server

Managing the Container

# Stop the container
docker stop goosecode-server

# Start an existing container
docker start goosecode-server

# Remove the container
docker rm goosecode-server

# View container logs
docker logs goosecode-server

# Access container shell
docker exec -it goosecode-server bash

Customizing Port or Password

docker run -d -p 8888:8080 -e PASSWORD="your-secure-password" --name goosecode-server --env-file .env goosecode-server

Goose Terminal API

The Goosecode Server includes an HTTP API for interacting with the terminal and accessing Goose conversation logs.

API Features:

• Send commands to the tmux terminal
• List active tmux sessions
• Retrieve Goose conversation logs
• Stream conversation updates in real-time using Server-Sent Events

The API is enabled by default when starting the container and runs on port 8000.

• Swagger documentation: http://localhost:8000/docs
• API base URL: http://localhost:8000/api/

Command-line options:

# Disable the Goose API
./run.sh --no-goose-api

# Change the API port
./run.sh --api-port=9000

For more details about the API, including examples and the streaming client, see the Goose API README.

Troubleshooting

Goose AI Issues

Container Issues

Built with ❤️ for developers