FastEdge VSCode Extension

A VS Code extension for building, running, and debugging Gcore FastEdge applications — with a Postman-like interface for crafting requests and inspecting responses.

Supports both HTTP apps and CDN apps across three languages:

     

How it works

The extension compiles your code into a WASM binary using language-specific build tools, then serves it locally using a bundled debugger — no external tools required.

A webview panel opens inside VS Code where you can:

• Build requests (URL, method, headers, body)
• Send them to your running app
• Inspect the response (status, headers, body)
• Load and save test configurations

Each app gets its own isolated server instance on a port in the range 5179–5188, so you can debug multiple apps in the same workspace simultaneously.

Prerequisites

You need the build tools for your chosen language installed:

Rust (HTTP or CDN apps):

rustup target add wasm32-wasip1

JavaScript (HTTP apps):

npm install --save-dev @gcoredev/fastedge-sdk-js

AssemblyScript (CDN apps):

npm install --save-dev assemblyscript @assemblyscript/wasi-shim @gcoredev/proxy-wasm-sdk-as

More detail can be found in the SDK documentation linked above.

Installing the extension

This extension can be installed from the Visual Studio Marketplace: FastEdge Launcher

It is also possible to install from source: Releases

Running your first application

Press F5 in VS Code (or Command Palette → Debug: Start Debug).

When running for the first time, you'll need a .vscode/launch.json. The easiest way is to let the extension create one:

Command Palette (Ctrl+Shift+P) → FastEdge: Initialize workspace (create launch.json)

Example launch.json

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "FastEdge App Runner: Launch",
      "type": "fastedge",
      "request": "launch",
      "entrypoint": "file"
    }
  ]
}

The entrypoint field controls how the build finds your source code:

These are the only configuration values read from launch.json. Runtime arguments (env vars, headers, etc.) are configured separately — see Runtime Configuration below.

Language detection

The extension auto-detects your project language:

Commands

Available from the Command Palette (Ctrl+Shift+P):

Explorer context menu

Right-click actions in the file explorer:

AI agents (MCP)

FastEdge (Generate mcp.json) adds the FastEdge MCP server to .vscode/mcp.json (Docker required). It asks how the server reaches your Gcore account:

• Sign in with your Gcore account (recommended): no key goes into mcp.json. On the first API call your agent offers to sign you in: you approve in your browser in the Gcore portal, and the MCP server gets a time-limited API token (8 hours by default, 7 days at most). The server's token broker holds it; the agent never sees it. The token is cached as plaintext in the fastedge-session Docker volume until it expires. Inside the container only the MCP server's token broker can read it, but anyone who can run Docker containers on this machine can read it too. To keep this sign-in's token unusable on disk instead, choose Only for this MCP server session on the approval page: the token is then encrypted to the running MCP server and you approve again the next time it starts. A session saved earlier with "Keep me signed in" stays usable until it expires or you sign out. The volume is shared with the FastEdge plugins for Claude Code, Codex and Cursor, so signing in once covers them all.
• Use an API key: the existing flow. The key is written to mcp.json (or, in Codespaces, read from a Codespace secret), so keep the file out of version control. The project folder is mounted into the MCP server's container, so the project's own build scripts (npm, cargo) can read that file too; managing the key's security is up to you.

In Codespaces or other remote setups the browser sign-in may not reach the container; use an API key there.

Runtime Configuration

Environment variables, secrets, request headers, and response headers are configured through test configuration files — not launch.json.

Primary: fastedge-config.test.json

The debugger UI provides built-in controls to set environment variables, secrets, and headers. These are saved to and loaded from fastedge-config.test.json in your app root, using native file dialogs.

Alternative: dotenv files

You can also provide runtime arguments via .env files that the extension auto-discovers from your app root directory.

Please be aware that if you are adding sensitive information to these files, they should be added to your .gitignore:

# VSCode workspace
.vscode/

# dotenv files
.env
.env.*

# Build artifacts
.fastedge-debug/

For more information on how the extension locates and uses dotenv files, see DOTENV.md.

Settings

To view the bundled debugger version:

1. Open Settings (Ctrl+, or Cmd+,)
2. Search for "FastEdge"