Flexygo Core VS Code Extension

A Visual Studio Code extension for managing Flexygo Core projects directly from your development environment, through a dedicated Flexygo panel in the Activity Bar.

Features

Flexygo panel (sidebar)

Click the Flexygo icon in the Activity Bar to open the panel. It shows, for the currently open Flexygo solution:

• Status
  • Installed Flexygo version (namespace + version), with an indicator when a newer stable version is available.
  • Live connection status for ConfConnectionString and DataConnectionString, read from appsettings.json / appsettings.Development.json (Development overrides the base file, same as ASP.NET Core). Each one is checked with a real database connection, so it only shows green when the target database actually exists and responds — not just that the server is reachable. From there you can configure the connection string (Server / Database / User / Password, written to appsettings.Development.json) or open a query in the SQL Server (mssql) extension.
  • Active Origin, which can be switched with Change Origin.
  • Refreshes automatically when those config files change, or on demand via the refresh icon.
• Actions
  • Debug (also F5) — starts the workspace's debug compound if there is one (e.g. "Launch Full Stack"), otherwise lets you pick a configuration from .vscode/launch.json. If the Backend or Frontend port is already taken, offers the next free ones and updates the appsettings files.
  • Publish Databases — builds each *.Conf.Database.sqlproj / *.Data.Database.sqlproj and publishes it with SqlPackage against the connection string the Backend project itself uses. SqlPackage (microsoft.sqlpackage .NET global tool) is installed automatically when missing (never auto-updated).
  • Generate NuGets — creates custom NuGet packages for your Flexygo product (semantic version input, validated).
  • Generate & Publish NuGets / Build & Publish Docker Images — with saved targets; secrets are kept in VS Code's SecretStorage.
  • Publish Docker — docker compose up in a terminal.
  • Deploy Product (beta) — registers the solution as an ahora-cenit product and verifies it with a throwaway test deployment.
  • Update Flexygo Version — updates the Flexygo product to a chosen or latest available version.
  • Clear NuGet Cache, Check Updates (the whole work environment: SDK, Node.js, IIS, SQL Server, Docker, VS Code and extensions, Flexygo tools and templates).
  • Create New Product — when the open folder is empty, scaffolds a product from a *.Product.Template package.
  • Migrate to Flexygo Core — when the folder is a classic Flexygo (.NET Framework) project.
• Need help? — quick links to Help (ayuda.ahora.es) and Support (flexygodesk.ahora.es); both URLs are configurable via flexygo.helpUrl / flexygo.supportUrl.

All solution actions validate that the workspace is a real Flexygo solution (*.Backend, *.Frontend, *.Conf.Database projects) before running.

Local SQL Server on dynamic ports

The extension connects to SQL Server over TCP only (the .NET app can also use Shared Memory locally). When the server is local (localhost, ., (local), the machine name) and the connection string has no explicit port, the extension reads the instance's real TCP port (fixed or dynamic) from the registry, so Server=localhost works even when SQL Server is not on 1433 and named instances don't need the SQL Server Browser service. An explicit host,port is always used as is.

How to Access Commands

• Flexygo panel (recommended) — click the Flexygo icon in the Activity Bar.
• Command Palette (Ctrl+Shift+P / Cmd+Shift+P) — every action above, as Flexygo: ....
• Explorer Context Menu (right-click) — Generate NuGets / Publish Databases / Update Flexygo Version.

Prerequisites

Before using this extension, ensure you have:

1. .NET SDK (for running .NET Global Tools)
2. Visual Studio Code (v1.75.0 or higher)
3. A Flexygo solution (open the solution folder in VS Code)

Note: The extension will automatically install or update Flexygo.Tools.Product to the latest version when you run commands, so you don't need to install it manually.

For Extension Development

• Node.js (v18 or higher)
• TypeScript (installed automatically with dev dependencies)

Installation

For Development/Testing

1. Clone or navigate to this repository:

   cd "C:\Codigo GIT\Flexygo\flexygo-core-vscode-extension"
   

2. Install dependencies:

   npm install
   

3. Compile the TypeScript code:

   npm run compile
   

4. Press F5 in VS Code to launch the Extension Development Host

For Production Use

1. Package the extension as VSIX:

   npm run package
   

2. Install the generated .vsix file:

   • In VS Code, go to Extensions view (Ctrl+Shift+X)
   • Click the ... menu at the top
   • Select "Install from VSIX..."
   • Choose the generated flexygo-core-vscode-extension-1.1.0.vsix file

Development

Project Structure

flexygo-core-vscode-extension/
├── src/
│   ├── extension.ts               # Main extension entry point
│   ├── panel/
│   │   ├── flexygoPanelProvider.ts # Sidebar webview: status + actions
│   │   ├── checkUpdatesPanel.ts    # Work environment inventory (see utils/environmentInspector.ts)
│   │   ├── deployProductPanel.ts   # Deploy Product (Cenit) wizard
│   │   ├── migrateToCorePanel.ts   # Migrate to Flexygo Core window
│   │   └── operationReportPanel.ts # Step/error report (Publish Databases)
│   ├── commands/                  # One file per command (debugProject, generateNugets,
│   │                              # publishDatabases, publishNugets, publishDockerImages,
│   │                              # updateProduct, changeOrigin, configureConnectionString,
│   │                              # openDatabaseQuery, createProduct, clearNugetCache, ...)
│   └── utils/
│       ├── appSettingsReader.ts        # Reads effective ConnectionStrings from appsettings*.json
│       ├── dbConnectionChecker.ts      # Real SQL connectivity check (shared SQL connection helper)
│       ├── sqlServerAddress.ts         # host\instance,port formatting and local TCP port resolution
│       ├── cenitClient.ts              # ahora-cenit platform API (Deploy Product)
│       ├── flexygoVersionDetector.ts   # Detects installed Flexygo version
│       ├── frameworkProjectDetector.ts # Detects classic Flexygo (.NET Framework) projects
│       ├── nugetVersionFetcher.ts      # Queries the NuGet feed for available versions
│       ├── portChecker.ts              # Backend/Frontend port availability before debugging
│       ├── processExecutor.ts          # Utility for executing external processes
│       ├── productDetector.ts          # Detects/asks for the product namespace
│       ├── skillInstaller.ts           # Installs the flexygo-migrar-core Claude Code skill
│       ├── solutionValidator.ts        # Validates the Flexygo solution structure
│       └── ...                         # Other helpers (versions, credentials, docker, origins)
├── resources/skills/              # Bundled Claude Code skill (flexygo-migrar-core)
├── l10n/                          # Runtime string translations (Spanish)
├── out/                           # Compiled JavaScript output
├── .vscode/
│   ├── launch.json               # Debug configuration
│   └── tasks.json                # Build tasks
├── package.json                   # Extension manifest
├── tsconfig.json                  # TypeScript configuration
└── README.md                      # This file

Running and Debugging

1. Open the project in VS Code:

   code "C:\Codigo GIT\Flexygo\flexygo-core-vscode-extension"
   

2. Press F5 to start debugging

   • This will compile the code and launch a new Extension Development Host window
   • Set breakpoints in the TypeScript source files as needed

3. In the Extension Development Host:

   • Open the Command Palette (Ctrl+Shift+P)
   • Run the Flexygo commands
   • View output in the "Flexygo Core" output channel

Available NPM Scripts

• npm run compile - Compile TypeScript to JavaScript
• npm run watch - Watch for changes and compile automatically
• npm run package - Create a .vsix package for distribution
• npm run lint - Run ESLint on the source code

Making Changes

After modifying the source code:

1. The watch task will automatically recompile (if running)
2. Press Ctrl+R in the Extension Development Host to reload
3. Or press F5 again to restart the debug session

Configuration

How It Works

The extension uses the flexygo-product .NET Global Tool to execute operations:

Automatic Tool Management:

• Before each command, the extension automatically runs:

  dotnet tool update --global Flexygo.Tools.Product
  

• This ensures you always have the latest version of the tool
• If not installed, it will be installed automatically
• If already installed, it will be updated to the latest version

Generate NuGets:

flexygo-product nuget -s "SOLUTION_PATH" -v VERSION -c Release

• Uses the currently open workspace folder as the solution path
• Prompts you for the version number
• Uses Release configuration by default

Update Product:

flexygo-product update -s "SOLUTION_PATH"

• Uses the currently open workspace folder as the solution path
• Updates to the latest available Flexygo version (no version specified)

Important Notes

1. Open Your Solution: Always open your Flexygo solution folder in VS Code before running commands
2. Valid Flexygo Solution: The extension validates that your solution contains the required Flexygo project structure (*.Backend, *.Frontend, *.Conf.Database)
3. .NET SDK Required: Ensure .NET SDK is installed for the tool management to work
4. Automatic Updates: The extension automatically ensures the tool is up to date before each operation
5. Internet Connection: First-time installation or updates require internet connectivity
6. Working Directory: The extension uses the first workspace folder as the solution path
7. Output Logging: All commands log detailed output to the "Flexygo Core" output channel

Output and Logging

All command execution is logged to the Flexygo Core output channel:

• View → Output → Select "Flexygo Core" from the dropdown
• Shows command execution, stdout, stderr, and exit codes
• Helps with troubleshooting and debugging

Error Handling

The extension provides comprehensive error handling:

• Validation: Version numbers are validated before execution
• Progress notifications: Visual feedback during long-running operations
• Error messages: Clear, actionable error notifications
• Detailed logging: Full output in the Flexygo Core channel
• Exit codes: Proper handling of process exit codes

Troubleshooting

Extension doesn't activate

• Check VS Code version (minimum 1.75.0)
• Run npm install to ensure dependencies are installed
• Check the Output panel (Help → Toggle Developer Tools → Console) for errors

Commands not visible

• Reload VS Code window (Ctrl+R in Extension Development Host)
• Check that the extension is activated (look for "Flexygo Core extension is ready!" notification)

Process execution fails

• Verify flexygo-product is installed: Run flexygo-product --help in a terminal
• Check PATH: Ensure .NET Global Tools are in your PATH
• Reinstall if needed:

  dotnet tool uninstall --global Flexygo.Tools.Product
  dotnet tool install --global Flexygo.Tools.Product
  

• Open correct folder: Ensure you have a Flexygo solution folder open in VS Code
• Review output: Check the "Flexygo Core" output channel for detailed error messages

"No workspace folder open" error

• Open your Flexygo solution folder in VS Code (File → Open Folder)
• The solution folder should contain your .sln file

Tool not found error

• Verify installation: dotnet tool list --global | findstr Flexygo
• Check .NET SDK is installed: dotnet --version
• Restart VS Code after installing the tool

Contributing

When contributing to this extension:

1. Follow the existing code structure
2. Maintain TypeScript strict mode compliance
3. Add appropriate error handling
4. Update this README if adding new features
5. Test thoroughly in the Extension Development Host

References

• Flexygo Documentation
• VS Code Extension API
• VS Code Extension Samples

License

Copyright © 2026 Flexygo. All rights reserved.

Version History

See CHANGELOG.md for the full list.

1.1.0

• Flexygo sidebar panel with live database/version/origin status
• Debug with port conflict detection, Publish Databases, Change Origin, connection string configuration and query
• Publish NuGets / Docker images, Deploy Product (beta) to ahora-cenit, Create New Product, Migrate to Flexygo Core
• Local SQL Server on dynamic ports now connects with Server=localhost

1.0.0 (Initial Release)

• Generate NuGets command with version validation
• Update Product command with confirmation dialog
• Integrated output channel logging
• Error handling and progress notifications
• Context menu integration