Logic Apps Local Dev Tools

A VS Code extension that streamlines local development and debugging for Azure Logic Apps Standard projects running in Docker or locally.

Features

Core Capabilities

• Run Trigger: Execute workflow triggers directly from the extension with a single click - supports Manual, Recurrence, and Request/HTTP triggers with JSON input validation and auto-refresh
• Multi-Endpoint Support: Connect to multiple Logic Apps runtime endpoints simultaneously, perfect for managing multiple containerized instances or different environments
• Enhanced Workflow Metadata: View workflow kind (Stateful/Stateless), triggers, health status, and enabled/disabled state at a glance
• HTTP Trigger Callback URLs: Get HTTP trigger callback URLs with one click - automatically replaces internal container URLs with accessible endpoints (toggle show/hide)
• Instance Overview: See detailed statistics for each Logic Apps instance including workflow counts, health status, and more
• Smart Endpoint Caching: Automatically remembers your last-used endpoints for quick reopening without re-entering URLs
• Quick Reopen: Instantly reopen the panel with cached endpoints using a dedicated command
• Runtime Detection: Automatically detect and connect to local Logic Apps Standard runtime (Docker or host) and Azurite storage emulator
• Run History Navigation: Custom webview panel to browse run history, workflow details, and action input/output using the Logic Apps management API
• Flow Diagram Visualization: Hierarchical text-based flow diagram showing workflow execution structure with status indicators (🟢 succeeded, 🔴 failed, ⚪ skipped). Toggle with "Show Flow" button to quickly understand workflow execution paths
• Collapsible UI: All actions and loop iterations can be collapsed/expanded to reduce scrolling and improve navigation through complex workflows
• Automatic Key Management: Automatically retrieves the local host master key when needed (or use a manually configured key)
• Action-Level Debugging: View detailed input and output for each workflow action by drilling into run details
• Loop Iteration Viewer: Automatically detects Foreach and Do Until scopes via the workflow definition, hides loop children from the main timeline, and loads per-iteration child action payloads on demand with full expand/collapse support

Requirements

• Azure Logic Apps Standard runtime (local host or container) exposing the management API on port 7071 or custom port
• Azurite storage emulator for local development (optional but recommended)
• VS Code version 1.105.0 or higher
• Optional: LogicAppsUX Standalone designer for visual workflow authoring (see https://github.com/Azure/LogicAppsUX)

Usage

Quick Start

1. Start your Logic Apps runtime: Ensure your Logic Apps Standard runtime(s) and Azurite are running (either on host or in Docker)
2. Open VS Code: Open your Logic Apps project in VS Code
3. Open Command Palette: Press Cmd/Ctrl+Shift+P
4. Available Commands:
   • LogicAppRunHistory: Open Logic Apps Run History Panel - Open the main panel to view instances and workflows (with smart endpoint caching)
   • LogicAppRunHistory: Reopen Last Run History Panel - Quickly reopen the panel with your last-used endpoints (no prompt)
   • LogicAppRunHistory: Detect Logic Apps Runtime and Azurite - Automatically detect running Logic Apps and Azurite instances
   • LogicAppRunHistory: Clear Cached Endpoints - Reset cached endpoints to use configured defaults

Working with Multiple Endpoints

When opening the Run History Panel, you can connect to multiple Logic Apps instances:

• Manual Entry: Enter multiple endpoints separated by commas when prompted:

  http://localhost:7071/runtime/, http://localhost:9898/runtime/
  

• Use Settings: Leave the prompt blank to use endpoints configured in VS Code settings
• Parallel Connection: The extension connects to all endpoints simultaneously for fast loading
• Smart Caching: Your last-used endpoints are automatically cached and pre-filled the next time you open the panel
• Quick Reopen: Use "Reopen Last Run History Panel" to instantly reopen with cached endpoints (no prompt)
• Reset Cache: Use "Clear Cached Endpoints" if you want to start fresh with default settings

Authentication

The extension handles authentication automatically:

• Auto-fetches the local host master key (/_master) when needed
• Alternatively, configure a specific API key in settings (logicAppsLocalDevTools.managementApi.apiKey)
• No additional configuration required for local development

Navigating Run History

1. Open the Run History Panel to see all connected instances
2. Click on an instance to view its workflows with detailed metadata
3. Click "View Runs" on any workflow to see execution history
4. Click on a specific run to view action-level input/output details
5. For any Foreach or Until action, select View All Iterations to expand the loop. The extension uses the workflow definition (not just action names) to discover every nested child action—even when they live inside scopes, conditions, or branches—and fetches the correct repetition payloads from the management API. Each iteration then shows the full set of child actions with working payload links.
6. Use the "Back" button to navigate up the hierarchy

Multi-Endpoint Support

Connect to multiple Logic Apps endpoints simultaneously - perfect for:

• Multiple Logic Apps runtimes running on different ports
• Different environments (dev, staging, production) running locally
• Containerized Logic Apps with different port mappings
• Testing across multiple instances simultaneously

How Multi-Endpoint Works

1. Configure Endpoints: Set multiple endpoints in VS Code settings or provide them when prompted
2. Parallel Connection: The extension connects to all endpoints in parallel for fast loading
3. Unified View: All instances from all endpoints appear in a single overview panel
4. Smart Routing: Each workflow operation automatically uses the correct endpoint

Instance Overview Panel

The run history panel provides a comprehensive instances overview:

Instance Statistics:

• Total workflow count
• Enabled vs. Disabled workflow counts
• Stateful vs. Stateless workflow distribution
• Healthy workflow count
• Host URL and last fetch timestamp

Actions:

• View all workflows for any instance with detailed metadata
• Navigate into workflow run history
• Get HTTP trigger callback URLs with one click
• Drill down through instance → workflow → runs → action details hierarchy

Workflow Metadata Display

Each workflow shows rich metadata:

• Workflow Kind: Stateful or Stateless badge
• Status: Enabled or Disabled indicator
• Health State: Healthy or Unhealthy status
• Triggers: List of all triggers with their types (HTTP, Recurrence, Request, etc.)
• Callback URLs: One-click retrieval for HTTP triggers
  • Automatic URL adjustment for container environments (replaces internal hostnames like 172.x.x.x with public endpoints)
  • Ready to use in tools like Postman, curl, or external applications

Extension Settings

Configure the extension via VS Code settings (Cmd/Ctrl+, or Command Palette → Preferences: Open Settings (UI)):

Primary Settings

Deprecated Settings

Configuration Examples

Single Local Instance (Default):

{
  "logicAppsLocalDevTools.managementApi.endpoints": [
    "http://localhost:7071/runtime/"
  ]
}

Multiple Docker Containers:

{
  "logicAppsLocalDevTools.managementApi.endpoints": [
    "http://localhost:7071/runtime/",
    "http://localhost:8071/runtime/",
    "http://localhost:9071/runtime/"
  ]
}

Custom Host/Port:

{
  "logicAppsLocalDevTools.managementApi.endpoints": [
    "http://my-host:7071/runtime/",
    "http://127.0.0.1:9999/runtime/"
  ]
}

With API Key:

{
  "logicAppsLocalDevTools.managementApi.endpoints": [
    "http://localhost:7071/runtime/"
  ],
  "logicAppsLocalDevTools.managementApi.apiKey": "your-api-key-here"
}

Notes

• The extension automatically appends /webhooks/workflow/api/management to each endpoint
• For non-Docker setups or custom ports, configure endpoints to match your runtime configuration
• Runtime detection and "Open Backend Logic Apps UX" commands use configured endpoints as fallback

Troubleshooting

Common Issues and Solutions

Problem: Extension can't connect to Logic Apps runtime

• Solution: Verify the runtime is running: curl http://localhost:7071/runtime/webhooks/workflow/api/management/workflows
• Check that the management API port (default 7071) is exposed and accessible
• For Docker: Ensure port mapping is correct in your docker-compose.yml or docker run command
• If cached endpoints are causing issues, use "Clear Cached Endpoints" command to reset

Problem: "Failed to fetch workflows" error

• Solution: Check that Azurite is running and accessible
• Verify the Logic Apps runtime has a valid connection string to Azurite
• Ensure the AzureWebJobsStorage environment variable is set correctly in your Logic Apps configuration
• Check the Logic Apps runtime logs for detailed error messages

Problem: Callback URLs show internal container IPs (172.x.x.x)

• Solution: The extension automatically replaces these, but ensure you're using version 0.0.2 or later
• If the issue persists, check your endpoint configuration - the extension uses the configured endpoint as the public URL

Problem: "Unauthorized" or 401 errors

• Solution: The extension auto-retrieves the _master key. If this fails:
  • Manually set logicAppsLocalDevTools.managementApi.apiKey in settings
  • Retrieve the key manually: curl http://localhost:7071/admin/host/systemkeys/_master
  • Check that the /admin endpoint is accessible (required for auto-key retrieval)

Problem: Multiple endpoints not showing all instances

• Solution: Check that all runtime URLs are correct and reachable
• Each endpoint must end with /runtime/ (the extension appends the management path)
• Check VS Code Developer Tools Console for connection errors: Help > Toggle Developer Tools

Problem: Run history panel is blank

• Solution: Ensure workflows have been executed at least once
• Stateless workflows may not retain run history depending on configuration
• Try triggering a workflow manually and refresh the panel

Problem: Extension commands not appearing in Command Palette

• Solution: Reload VS Code: Developer: Reload Window from Command Palette
• Check that the extension is installed and enabled in Extensions view
• Verify no extension activation errors in Output panel: View > Output → Select "Logic Apps Local Dev Tools"

Docker-Specific Issues

Problem: Logic Apps container starts but extension can't connect

• Solution: Verify port binding with docker ps - ensure 7071 is mapped to host
• Check container networking mode - use bridge or host mode
• If using Docker Compose, ensure the service is on an accessible network

Problem: Azurite connection failures in Docker

• Solution: Use Azurite container connection string: DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=...;BlobEndpoint=http://azurite:10000/devstoreaccount1;QueueEndpoint=http://azurite:10001/devstoreaccount1;TableEndpoint=http://azurite:10002/devstoreaccount1
• Ensure Logic Apps and Azurite containers are on the same Docker network
• Check container DNS resolution: docker exec <container> ping azurite

Getting Help

• Check the GitHub Issues for known problems
• Review Logic Apps runtime logs: docker logs <container-name> or check local logs
• Enable VS Code Developer Tools for extension debug output: Help > Toggle Developer Tools → Console tab
• Report bugs with detailed error messages, VS Code version, and extension version

Known Issues

• Some workflow operations (trigger, cancel run) are not yet implemented
• Screenshot references in documentation may not display if images are missing

📚 Documentation

Comprehensive documentation is available in the docs/ directory:

• Architecture Guide - System design, module responsibilities, and data flow
• Refactoring Summary - Recent code improvements and metrics
• Testing Guide - Test infrastructure and development tools
• Payload Downloader - Offline development tool

See docs/README.md for the complete documentation index.

Release Notes

0.0.8

• Runtime & Azurite Detector: New LogicAppRunHistory: Detect Logic Apps Runtime and Azurite command inspects local ports, Docker containers, and local.settings.json connection strings to report reachable endpoints so you know whether the runtime and emulator are ready before opening the panel.
• Faster panel reopen: Smart endpoint caching powers the new Reopen Last Run History Panel command plus a cache clearing command, letting you jump between multi-endpoint environments without repeatedly re-entering URLs.
• Nested container viewer: ForEach, Until, Scope, Condition, and Switch actions now fetch every descendant action, hide duplicates from the top-level list, render nested case/branch layouts, and show gray Reason: labels for skipped actions for parity with the Logic Apps portal.
• Offline tooling: Added documented helper scripts—npm run test:render, npm run inspect:run, and npm run download:payloads—so you can render HTML, debug repetitions, or capture payloads without packaging/installing the extension.
• Docs & tests: Expanded docs under docs/ (architecture, refactoring, testing, payload downloader) and grew the automated test suite to 77 tests covering client APIs, rendering, utilities, and nested container edge cases.

0.0.5

• Extension Icon: Updated to new "Run History Viewer" design
• Documentation: Comprehensive CONTRIBUTING.md and docs/ guides
• HTTP Method Display: Callback URLs show HTTP verb badges (GET, POST, etc.)
• Testing: 57 unit tests covering client API, rendering, and utilities
• Marketplace: Added keywords and categories for better discoverability
• Package Structure: Excluded Claude Code configuration from packaging

0.0.2

• Enhanced Workflow Metadata: Added workflow kind (Stateful/Stateless), trigger information, enabled/disabled status, and health state
• HTTP Trigger Callback URLs: Click "Get URL" button to retrieve callback URLs for HTTP triggers
• Automatic URL Replacement: Internal container URLs are automatically replaced with public endpoints
• Enhanced Instance Overview: Display detailed statistics including workflow counts, stateful/stateless counts, and health metrics
• Improved UI: Better visual presentation of workflow details with badges and status indicators
• API Updates: Uses correct /listCallbackUrl endpoint with POST method and API version 2018-11-01

0.0.1

• Initial release: runtime detection, designer launch, run history panel with drill-in
• Multi-endpoint support for connecting to multiple Logic Apps instances
• Instances overview with workflow grouping
• Run history navigation and action I/O viewing

Development

Prerequisites

• Node.js 22.x or higher
• npm 10.x or higher
• VS Code 1.105.0 or higher

Build & Test Locally

From the repository root:

# Install dependencies
npm install

# Compile TypeScript
npm run compile

# Watch mode for development (auto-recompile on changes)
npm run watch

# Run linting
npm run lint

# Run unit tests (fast, Node-only)
npm run test:unit

# Run full test suite (including VS Code integration tests)
npm test

# Package as VSIX for distribution
npx @vscode/vsce package

Install the Packaged VSIX

Via Command Line:

# Install the VSIX into your local VS Code (macOS/Linux)
code --install-extension logic-apps-run-history-view-tool-0.0.8.vsix

# Force reinstall/upgrade
code --install-extension logic-apps-run-history-view-tool-0.0.8.vsix --force

Via VS Code UI:

1. Open VS Code
2. Go to Extensions view (Cmd/Ctrl+Shift+X)
3. Click the "..." menu → "Install from VSIX..."
4. Select the .vsix file

Testing

The extension ships with 77 automated tests that exercise the management client, HTML rendering logic (including nested containers), and shared utilities:

Test Coverage:

• Client Tests (16 tests): Workflow/run retrieval, trigger callback URLs, hostname replacement, repetitions APIs, error handling
• Rendering Tests (33 tests): Run details HTML, ForEach/Until iteration rendering, nested Switch/Condition/Scope layouts, XSS prevention, skipped vs failed messaging
• Utils Tests (28 tests): HTML escaping, URL helpers, repetition helpers, payload normalization and formatting edge cases

Running Tests:

# Run unit tests only (fast)
npm run test:unit

# Generate standalone HTML to inspect run history rendering
npm run test:render -- --fixture rundetails/reference_foreachscope.json

# Run with watch mode during development
npm run test:unit -- --watch

# Run full test suite including integration tests
npm test

Run Inspector (integration helper)

Use the integration helper script to inspect real runs and loop repetitions outside the VS Code UI:

npm run inspect:run -- \
  --baseUrl http://localhost:7071/runtime/webhooks/workflow/api/management \
  --workflow wf1 \
  --run 08584385668211059667393040643CU00 \
  --action Until \
  --apiKey <function-key>

• --baseUrl is the management endpoint (same one the extension calls).
• Supply --workflow, --run, and optionally --action to focus on a loop.
• You can use environment variables instead: LA_MGMT_BASE, LA_WORKFLOW, LA_RUN, LA_ACTION, LA_API_KEY, LA_MAX_PROBE, etc.
• The script prints the run summary, action list, and detailed repetition payloads (including child actions), which is useful for reproducing “Unknown iteration count” issues quickly.

Payload Downloader (offline payload capture)

Download every trigger/action input and output from a Logic Apps run for offline debugging or to build new fixtures:

npm run download:payloads -- \
  --baseUrl http://localhost:7071/runtime/webhooks/workflow/api/management \
  --workflow wf4 \
  --run 08584385874391237197677428001CU00 \
  --output ./my-run-payloads \
  --includeRepetitions

• Creates a structured folder with run-metadata.json, trigger/action payloads, and optional per-iteration files under repetitions/
• Works with env vars (LA_MGMT_BASE, LA_WORKFLOW, LA_RUN, etc.) so you can omit repeated arguments
• Perfect for capturing realistic data for unit tests or sharing repro steps with teammates
• See docs/PAYLOAD_DOWNLOADER_GUIDE.md for detailed usage patterns

Development Tips

• If the code command is not available, install it via Command Palette → "Shell Command: Install 'code' command in PATH"
• Use npm run watch during development for automatic recompilation
• Unit tests run with Mocha and ts-node, no VS Code instance required
• Integration tests run in a full VS Code environment and require @vscode/test-electron
• Check out/ directory for compiled JavaScript output
• Test files are in test/ directory with .test.ts extension

Common Development Issues

• Packaging fails: Ensure package.json is valid JSON and npm run compile succeeds without errors
• Tests fail: Run npm run compile first to ensure TypeScript is compiled
• Extension doesn't activate: Check for activation errors in Output panel: View > Output → "Logic Apps Local Dev Tools"

Credits

This extension's "Run Trigger" feature was inspired by and references best practices from vscode-logicapp-runner by J-Cat. We appreciate their work in making Logic Apps local development easier for the community.

Enjoy local Logic Apps development!

Screenshots

Below are screenshots of the extension in action:

Logic Apps Instances Overview

Instance Details and Workflows

Docker View

Run History and Details

Execution View with Flow Diagram

Command Palette