Rokket GSD

The GSD-PI / GSD V2 VS Code Extension

Built on gsd-pi by Glittercowboy (Lex Christopherson), based on Pi Mono by Mario Zechner ❤️

A full-featured VS Code frontend for the gsd-pi AI coding agent.
Streaming responses, 40+ tool visualizations, Telegram relay with voice transcription,
parallel worker dashboards, model controls, four built-in themes, and deep workflow integration.

What Is This?

Rokket GSD turns the gsd-pi CLI into a native VS Code experience. Streaming responses, 40+ tool visualizations, Telegram relay with voice transcription, parallel worker dashboards, model controls, four built-in themes, and deep workflow integration. Everything runs inside your editor.

The extension spawns GSD as a child process over JSON-RPC (gsd --mode rpc), giving the agent full access to your workspace, tools, and configured providers while you get a proper UI on top.

✨ Highlights

⚠️ Prerequisites

[!IMPORTANT] Rokket GSD is a frontend for the GSD agent. It does not include the agent itself.

You need a working GSD environment before installing:

1. Node.js 18+ with npm
2. Git
3. VS Code 1.94+
4. gsd-pi installed globally:

   npm install -g gsd-pi
   

5. A configured AI provider in GSD (Anthropic, OpenAI, Google, etc. via API key or OAuth)

[!TIP] Run gsd in a terminal first to verify it works before installing the extension. If gsd doesn't work in your terminal, the extension won't work either.

📦 Installation

VS Code Marketplace

Search "Rokket GSD" in the Extensions sidebar, or install directly from the VS Code Marketplace.

One-Liner (macOS / Linux / Git Bash)

curl -sL https://raw.githubusercontent.com/Kile-Thomson/Rokket-GSD/main/install.sh | bash

One-Liner (Windows PowerShell)

irm https://raw.githubusercontent.com/Kile-Thomson/Rokket-GSD/main/install.ps1 | iex

git clone https://github.com/Kile-Thomson/Rokket-GSD.git
cd Rokket-GSD
npm install
npm run build
npx vsce package --no-dependencies
code --install-extension rokket-gsd-*.vsix --force

🏁 Getting Started

Once installed, follow these steps to get up and running:

1. Set up GSD (first time only)

If you haven't already, install and authenticate the GSD agent:

npm install -g gsd-pi
gsd

The first run walks you through provider authentication (Anthropic, OpenAI, Google, etc.). You'll need at least one configured provider before the extension will work.

2. Open Rokket GSD

• Click the rocket icon in the VS Code activity bar (left sidebar), or
• Press Ctrl+Shift+P → "Rokket GSD: Open"

The extension spawns a gsd process automatically — if everything is set up correctly, you'll see the welcome screen with quick-action chips.

3. Verify your setup

If something isn't right, the extension runs a health check on startup and shows a notification with specific fix instructions. You can also run /gsd doctor in the chat to diagnose issues.

4. (Optional) Connect Telegram

To relay conversations to a Telegram group with voice message support:

1. Create a bot — message @BotFather on Telegram, send /newbot, and copy the token
2. Add the bot to your Telegram group and make it an admin
3. Run the setup wizard — type /telegram in the Rokket GSD chat or use Ctrl+Shift+P → "Rokket GSD: Telegram Setup"
4. Paste your bot token when prompted — the wizard auto-detects your group and verifies the connection
5. (Optional) Enable voice transcription — run /telegram voice and enter an OpenAI API key for Whisper

All credentials are stored securely in VS Code's SecretStorage — never in config files or source code.

5. (Optional) Customize settings

Open VS Code Settings (Ctrl+,) and search for "gsd" to configure:

• Theme — choose from Classic, Phosphor, Clarity, or Forge
• Send key — switch to Ctrl+Enter if you prefer Enter for newlines
• Layout — open as sidebar panel or editor tab
• Auto-updates — enabled by default, checks GitHub Releases

🚀 Features

📂 Session History & Resume

• Browse previous sessions with searchable panel showing titles, dates, and message counts
• Resume any session with a single click, full context and conversation state injected on load
• Resume from welcome screen with the "↩ Resume" chip or /resume slash command
• Rename sessions with meaningful names for easy lookup later
• Delete sessions to clean up old conversations
• Each session gets its own GSD process with fully isolated state

⌨️ Slash Commands

Type / to open the command palette with 59+ commands:

🧠 Model & Thinking Controls

• Model picker grouped by provider with section headers, context window size, and reasoning capability tags
• Thinking level dropdown with off / minimal / low / medium / high / xhigh and descriptions for each level
• Model-aware thinking hides levels your model doesn't support. Extended thinking only shows for models that handle it.
• Context usage bar below the header with color-coded thresholds (green at 0-70%, amber at 70-90%, red at 90%+)
• Live session stats showing token count, session cost, and context pressure at a glance
• Dynamic model routing indicator flashes the model badge and announces via toast when gsd-pi switches models mid-task

💬 Streaming Chat

• Sequential segment rendering - text, thinking blocks, and tool calls stream in arrival order with no re-renders or layout jumps
• Full markdown with syntax-highlighted code blocks, tables, blockquotes, headings, inline code, and images
• Copy buttons on every code block and full assistant responses
• Image paste and drag-drop directly into the input area
• File attachments via button, drag-and-drop, or paste with type-specific icons and removable chips
• Message timestamps with relative times that update live and absolute times on hover
• Thinking blocks collapsed by default with line count indicator, expanded during streaming
• Steer while streaming to redirect the agent mid-task without stopping it
• Steer persistence — messages sent during auto-mode are saved to OVERRIDES.md and apply to all future tasks, not just the current turn
• Drag-to-resize input area for longer messages
• !command shortcut to run bash commands directly without the agent

🔧 Tool Execution Visualization

• Live tool calls with category-specific icons and color accents for 40+ tools
• Rich key arg display for lsp, browser_, github_, gsd_*, mcp_call, bash, and more
• Collapsible output with smart truncation for large results
• Parallel tool indicator with ⚡ badge and pulse animation when tools run concurrently
• Tool call grouping collapses consecutive read-only tools (file reads, searches, browser reads) into expandable summary rows
• Subagent results rendered as full markdown with usage pills showing token and cost breakdowns
• Clickable file paths that open directly in VS Code
• Shimmer animation on running tools so you always know what's active
• Duration tracking on every completed tool call
• Server-side tool indicators — compact inline cards for Anthropic's native server-side tools (web search, code execution) showing tool name, search query, spinner while running, and result count on completion

⚡ Auto-Mode Progress

• Live progress widget sticky above the input showing current task, phase, progress bars, elapsed time, cost, and active model
• Phase rendering with distinct labels and icons: Executing, Planning, Validating (✓), Completing, Blocked, Replanning
• Discussion-pause visibility shows 💬 "Awaiting Discussion" with a /gsd discuss hint when auto-mode pauses for slice discussion
• Pending captures badge (📌) in the progress widget for /gsd capture thoughts awaiting triage
• Workflow state badge in the header showing active milestone, slice, task, and current phase
• Auto-mode indicator with ⚡ Auto, ▸ Next, ⏸ Paused states
• Health widget — ambient system health bar in the footer showing system status, budget, provider issues, and environment errors
• Model health indicator — green/amber/red dot next to the model name reflecting current system health

📊 Parallel Worker Dashboard

• Worker cards during parallel auto-mode showing per-worker milestone ID, state badge, current unit, and cost
• State badges for Running, Paused, Stopped, and Error with distinct colors
• Budget usage bars per worker with green/orange/red thresholds at 80% and 100%
• Budget alert toast fires a VS Code warning when any worker crosses 80% of budget_ceiling
• Stale worker detection dims workers with old heartbeats and shows a "(stale)" label
• Graceful degradation to standard single-worker display when no parallel data exists

📈 Workflow Visualizer

• Full-page overlay via /gsd visualize with three tabs
• Progress tab with milestone header, progress bars, slice/task breakdown, milestone registry, blockers, and next action
• Metrics tab with cost breakdown, tool call counts, model usage, token breakdown, and context usage
• Health tab with system health status, budget info, environment warnings, and active model
• Auto-refresh every 5 seconds during active auto-mode
• Dashboard panel with milestone registry, slice/task progress, cost projections, and activity log

🤖 Agent Interaction

• Inline UI dialogs for confirm, select, input, and editor prompts rendered directly in the chat flow (no modal popups)
• Multi-select support with checkbox-style selection and confirm button
• Auto-compaction indicator overlay banner when context is being compacted
• Auto-retry indicator with countdown timer and abort button when the provider rate-limits
• Provider fallback alerts via toast when GSD auto-switches models due to rate limits, and again when the original provider recovers
• Crash recovery with restart button, exit code diagnostics, and full state cleanup

📡 Telegram Relay

• Stream conversations to Telegram — relay assistant messages to a Telegram group in real time
• Setup wizard via /telegram or the command palette with guided Bot Token → Group ID → Chat Title flow
• Voice message transcription — Telegram voice messages are transcribed via OpenAI Whisper and injected as user prompts
• Photo support — images sent in Telegram are forwarded to the agent as attachments
• Topic-based threading — each session creates a Telegram topic for organized conversations
• Streaming granularity control — configure as off, throttled, or final-only in settings
• Secure credential storage — Bot Token and OpenAI API key stored in VS Code's SecretStorage, never in source files

🎨 VS Code Integration

• Activity bar icon (rocket) with sidebar panel
• Flexible layout - open as sidebar or editor tab
• Status bar showing streaming state, active model, and session cost
• Working indicator with pulsing amber glow on the rocket logo while the agent is active
• Theme-aware - works with any VS Code color theme (light, dark, high contrast)
• Four built-in themes: Classic, Phosphor, Clarity, and Forge
• Auto-updates from GitHub Releases with one-click install notification
• HTML export from the command palette ("Rokket GSD: Export Milestone Report")
• What's New overlay on version upgrade with changelog viewer
• Welcome screen quick actions with clickable chips for Auto, Status, and Review
• Scroll-to-bottom FAB when scrolled up
• Toast notifications for action feedback

⌨️ Keyboard Shortcuts

[!TIP] Enable gsd.useCtrlEnterToSend in settings if you want Enter for newlines and Ctrl+Enter to send.

🔒 Security

• CSP enforcement — nonce-based Content Security Policy with no unsafe-inline in style-src or script-src
• DOMPurify sanitization on all rendered markdown with explicit attribute allowlist
• URL scheme allowlist restricting clickable links to http, https, and vscode
• Path traversal protection with workspace boundary validation and symlink resolution
• Command injection prevention using args arrays instead of shell interpolation; destructive bash pattern detection with modal confirmation
• Environment isolation stripping Electron/VS Code env vars before spawning GSD
• Download validation restricting update installs to GitHub URLs only
• Temp file size limit (50MB) on save operations
• No secrets in DOM — API keys and tokens are never rendered in the webview
• Buffer overflow protection — full JSON-RPC buffer reset (not truncation) to preserve protocol integrity

⚙️ Configuration

🛡️ Process Resilience

Built to handle real-world agent sessions that run for hours:

• Health monitoring with periodic pings to detect hung processes
• Environment isolation stripping Electron/VS Code env vars to prevent subprocess crashes
• Graceful shutdown handling session_shutdown events cleanly
• Force-kill and restart via UI button for stuck processes
• Duplicate spawn prevention via mutex per session
• Buffer overflow protection with full reset (not truncation) to preserve JSON-RPC protocol integrity

🏗️ Architecture

┌─────────────────────┐    postMessage     ┌─────────────────────┐
│   Webview (Chat UI) │ <───────────────> │   Extension Host     │
│                     │                   │                      │
│  Streaming render   │                   │  Dialog mapping      │
│  Tool visualization │                   │  File operations     │
│  Model/thinking     │                   │  Update checker      │
│  Session history    │                   │  Status bar          │
│  Slash commands     │                   │  Health monitoring   │
│  Worker dashboard   │                   │  Parallel polling    │
│  Agent cards        │                   │  Telegram bridge     │
└─────────────────────┘                   └──────────┬───────────┘
                                                     │ stdin/stdout
                                                     │ JSON-RPC
                                          ┌──────────▼───────────┐
                                          │   gsd --mode rpc     │
                                          │   (Child Process)    │
                                          └──────────────────────┘
                                                     │
                                          ┌──────────▼───────────┐
                                          │   Telegram Poller    │
                                          │   OpenAI Whisper     │
                                          └──────────────────────┘

• Webview — vanilla DOM (no framework), ~13K lines of TypeScript + 16 CSS modules + 3 theme files, esbuild-bundled IIFE. Sequential segment-based renderer with requestAnimationFrame batching for smooth streaming. CSS uses a semantic token layer (--gsd-*) bridging VS Code's theme system — components never reference --vscode-* directly.
• Extension Host — ~10K lines of TypeScript managing the GSD child process, routes messages, handles file operations, monitors health, polls parallel worker status, and coordinates the Telegram bridge. All hot-path I/O is async; polling runs via parallelized Promise.all.
• GSD Process — the full gsd-pi agent running via JSON-RPC over stdin/stdout. Each session gets its own process.
• Telegram Bridge — poller, coordinator, IPC, topic manager, and message formatter. Voice messages transcribed via OpenAI Whisper; photos forwarded as image attachments.

The extension ships as a .vsix with no runtime dependencies beyond VS Code and the gsd CLI. 1370 tests across 66 files.

git clone https://github.com/Kile-Thomson/Rokket-GSD.git
cd Rokket-GSD
npm install
npm run watch    # Rebuilds on file changes
# Press F5 in VS Code to launch Extension Development Host

src/
  extension/
    index.ts                # Entry point, commands, status bar
    rpc-client.ts           # JSON-RPC client over stdin/stdout
    webview-provider.ts     # Webview lifecycle, message routing
    message-dispatch.ts     # Inbound message routing (extension side)
    rpc-events.ts           # RPC event handlers
    auto-progress-poller.ts # Auto-mode progress polling (parallelized)
    parallel-status.ts      # Parallel worker status reader
    dashboard-parser.ts     # Dashboard data aggregation
    metrics-parser.ts       # Cost/token metrics parsing
    captures-parser.ts      # Pending capture count parsing
    state-parser.ts         # GSD workflow state parsing
    update-checker.ts       # Auto-update from GitHub Releases
    session-list-service.ts # Session history filesystem parser
    session-state.ts        # Per-session state management
    file-ops.ts             # File operations (export, save, access)
    health-check.ts         # Process health monitoring
    html-generator.ts       # Webview HTML + CSP generation
    watchdogs.ts            # Streaming/tool timeout watchdogs
    command-fallback.ts     # Slash command fallback handling
    telegram/               # Telegram relay (setup, polling, formatting, IPC)
    openai/                 # OpenAI Whisper voice transcription
  shared/
    types.ts                # Message protocol types (extension <> webview)
  webview/
    index.ts                # DOM setup, events, initialization
    renderer.ts             # Streaming segment renderer
    message-handler.ts      # Inbound message routing
    auto-progress.ts        # Auto-mode progress bar + worker cards
    visualizer.ts           # Workflow visualizer overlay
    dashboard.ts            # GSD dashboard overlay
    model-picker.ts         # Model selection overlay
    thinking-picker.ts      # Thinking level dropdown
    slash-menu.ts           # Slash command palette (45+ built-in commands)
    ui-dialogs.ts           # Inline confirm/select/input dialogs
    tool-grouping.ts        # Read-only tool collapse logic
    session-history.ts      # Session browser panel
    helpers.ts              # Markdown, formatting, tool display
    ui-updates.ts           # Header, footer, overlay updates
    keyboard.ts             # Keyboard shortcut handling
    state.ts                # Shared mutable state
    a11y.ts                 # Accessibility utilities
    toasts.ts               # Toast notification system
    file-handling.ts        # File attachment handling
    styles/
      tokens.css            # Semantic design tokens (--gsd-* layer)
      base.css              # Reset, typography, scrollbar
      layout.css            # Grid, panels, overlays
      input.css             # Chat input area
      entries.css           # Message bubbles, turns
      footer.css            # Status bar, badges
      tools.css             # Tool call cards
      overlays.css          # Modals, pickers, visualizer
      misc.css              # Focus rings, animations, utilities
      parallel.css          # Worker dashboard cards
      auto-progress.css     # Auto-mode progress widget
      dashboard.css         # GSD dashboard overlay
      toasts.css            # Toast notifications
      themes/
        phosphor.css        # Phosphor theme overrides
        clarity.css         # Clarity theme overrides
        forge.css           # Forge theme overrides
resources/
  gsd-logo.svg              # Activity bar icon
  rokket-icon.png            # Extension icon
  extensions/               # Bundled pi extensions (auto-installed)

Known Limitations

• Requires gsd-pi — this is a UI wrapper, not a standalone agent. The gsd CLI must be installed and configured separately.
• Some GSD custom UI commands rely on TUI widgets that VS Code webviews cannot render directly. /gsd status is supported via the structured dashboard renderer; other widget-dependent commands produce text-only output.

License

MIT

▲ ROKKETEK
_{Built by Kile Thomson}