VSCode Extension

Wendy for VS Code Extension

The Wendy for VS Code extension provides a complete development environment for building, deploying, and debugging applications on WendyOS devices directly from your editor. Whether you're developing in Swift, Python, or any containerized application, this extension streamlines your workflow with device management, one-click deployment, and integrated debugging.

Features Overview

• Device Discovery & Management: Automatically discover WendyOS devices on your network or connected via USB
• One-Click Deployment: Build and run applications on your device with a single command
• Integrated Debugging: Full debugging support for Swift (LLDB) and Python (debugpy)
• Agent Updates: Keep your WendyOS device's agent up to date from within VS Code
• OS Installation: Flash WendyOS onto supported devices directly from the editor
• WiFi Configuration: Connect your device to wireless networks without leaving your IDE

Installing the Extension

code --install-extension wendylabsinc.wendy-vscode

Getting Started

After installing the extension, you'll see a new Wendy icon in the Activity Bar on the left side of VS Code.

Clicking this icon reveals the Wendy sidebar with four main panels:

Prerequisites

Before using the extension, ensure you have:

• Wendy CLI installed on your development machine
• A WendyOS device (NVIDIA Jetson Orin Nano, NVIDIA Jetson Thor, or Raspberry Pi 5)
• For Swift development: The WendyOS Swift SDK and the Swift extension for VS Code
• For Python development: The Python extension for VS Code

Verify your Wendy CLI installation:

wendy --version

Selecting a Device

The Devices panel shows all discovered and manually added WendyOS devices. To select a device for deployment:

1. Click the Wendy icon in the Activity Bar to open the sidebar
2. In the Devices panel, you'll see your discovered devices
3. Click on a device to select it as your current target device
4. A checkmark icon indicates the currently selected device

Adding a Device Manually

If your device isn't automatically discovered (e.g., on a different network subnet), you can add it manually:

1. Click the + button in the Devices panel header
2. Enter the device hostname or IP address (e.g., wendyos-humble-pepper.local or 192.168.1.100)
3. Optionally specify a port if not using the default (e.g., 192.168.1.100:50051)
4. Press Enter to add the device

Viewing Device Information

Right-click on any device to access additional options, or click the info icon to view detailed device information:

The device info panel displays:

• Hostname: The device's network address
• Agent Version: The currently installed WendyOS Agent version
• Device ID: Unique device identifier
• Interface Type: How the device is connected (USB, Ethernet, or LAN)
• Running Applications: List of apps currently deployed on the device

Refreshing Devices

To refresh the device list and discover new devices:

• Click the refresh icon in the Devices panel header, or
• Use the Command Palette: Wendy: Refresh Devices

Updating the WendyOS Agent

Keeping your device's agent up to date ensures you have the latest features and bug fixes. To update the agent:

1. In the Devices panel, right-click on the device you want to update
2. Select Update Agent from the context menu
3. The extension will download and install the latest agent version
4. Wait for the update to complete - the device will briefly restart

You can also update the agent via the Command Palette:

1. Open the Command Palette (Cmd+Shift+P / Ctrl+Shift+P)
2. Run "Wendy: Update Agent"
3. Select the device to update if multiple devices are available

Installing WendyOS

The extension can flash WendyOS onto supported devices directly from VS Code. This is useful for:

• Setting up a new device for the first time
• Reinstalling WendyOS to resolve issues
• Updating to a newer WendyOS version

Prerequisites for OS Installation

• An SD card or NVMe drive connected to your development machine
• Sufficient disk space for the WendyOS image (typically 8GB+)
• Administrator/sudo access for disk operations

Flashing WendyOS

1. Connect your target storage device (SD card or NVMe) to your development machine
2. Open the Disks panel in the Wendy sidebar
3. Locate your target disk in the list

4. Right-click on the disk and select Flash WendyOS
5. Select your device type from the dropdown (e.g., NVIDIA Jetson Orin Nano, Raspberry Pi 5)
6. Confirm the operation when prompted

7. Wait for the flashing process to complete - this may take several minutes

Managing OS Cache

The Operating System Cache panel lets you manage downloaded WendyOS images:

• View cached images: Browse previously downloaded OS images
• Delete cached entries: Free up disk space by removing old images
• Reveal in Finder/Explorer: Open the cache directory in your file manager

The cache is stored at:

• macOS/Linux: ~/.wendy/cache
• Windows: %LOCALAPPDATA%\Wendy\cache

Configuring WiFi

Connect your WendyOS device to a wireless network directly from VS Code:

1. Right-click on a device in the Devices panel
2. Select Connect WiFi
3. The extension will scan for available networks
4. Select a network and enter the password when prompted

Building and Running Applications

Once you have a device selected, you can build and run your applications:

Using the Run Menu

1. Open a Swift package or Python project in VS Code
2. Press F5 or go to Run > Start Debugging
3. Select a Wendy debug configuration from the dropdown
4. Your application will be built, deployed to the device, and started with debugging enabled

Using Tasks

The extension provides custom Wendy tasks that integrate with VS Code's task system:

1. Open the Command Palette (Cmd+Shift+P / Ctrl+Shift+P)
2. Run "Tasks: Run Task"
3. Select a Wendy task (e.g., "Wendy: Run")

Debugging with Breakpoints

The Wendy extension provides full remote debugging support, allowing you to debug applications running on your WendyOS device as if they were running locally. This includes setting breakpoints, stepping through code, and inspecting variables.

Setting Breakpoints

To set a breakpoint in your code:

1. Open the source file you want to debug
2. Click in the gutter (left margin) next to the line number where you want to pause execution
3. A red dot appears indicating an active breakpoint

You can also:

• Conditional breakpoints: Right-click on a breakpoint and select "Edit Breakpoint" to add a condition
• Logpoints: Right-click in the gutter and select "Add Logpoint" to log messages without pausing
• Function breakpoints: In the Debug panel, click the "+" in the Breakpoints section to break on function entry

Starting a Debug Session

1. Set your breakpoints in the source code
2. Select your target WendyOS device in the Devices panel
3. Press F5 or click Run > Start Debugging
4. Select the appropriate debug configuration:
   • Swift: Debug [YourAppName] on WendyOS
   • Python: Debug Python App on WendyOS

The extension will:

1. Build your application
2. Deploy it to the selected device
3. Start the application with debugging enabled
4. Attach the debugger to the remote process

Debugging Controls

Once your application hits a breakpoint, you can use the debug toolbar:

Inspecting Variables

When paused at a breakpoint, you can inspect your application's state:

• Variables Panel: View local variables, function arguments, and global state
• Watch Panel: Add expressions to monitor specific values
• Hover: Hover over variables in the editor to see their current values
• Debug Console: Evaluate expressions and interact with your application

Call Stack

The Call Stack panel shows the execution path that led to the current breakpoint:

• Click on any frame to view its source code and local variables
• Navigate through the stack to understand the flow of execution

Debugging Swift Applications

For Swift applications, the extension uses LLDB (via lldb-dap) for remote debugging over port 4242.

The extension automatically generates debug configurations for each executable target in your Swift package:

Debug [YourAppName] on WendyOS

Requirements:

• WendyOS Swift SDK installed at ~/.swiftpm/swift-sdks/
• Swift extension for VS Code

Swift-specific debugging features:

• Full LLDB expression evaluation in the Debug Console
• View Swift types, optionals, and collections
• Set breakpoints in async/await code

Debugging Python Applications

For Python applications, the extension uses debugpy for remote debugging over port 5678.

Debug Python App on WendyOS

Requirements:

• Python extension for VS Code
• debugpy library installed in your application's container

Add debugpy to your project's requirements:

debugpy>=1.8.0

Python-specific debugging features:

• Evaluate Python expressions in the Debug Console
• View dictionaries, lists, and complex objects
• Debug multi-threaded applications
• Exception breakpoints for catching errors

Extension Settings

Configure the extension through VS Code settings (Cmd+, / Ctrl+,):

Troubleshooting

Device Not Discovered

If your device doesn't appear in the Devices panel:

1. Ensure the device is powered on and running WendyOS
2. Check your USB connection if using USB
3. Verify both devices are on the same network for LAN discovery
4. Try adding the device manually using its hostname or IP address
5. Check that mDNS/Bonjour is not blocked on your network

See Discovering Devices for more detailed troubleshooting.

Update Agent Fails

If agent updates fail:

1. Ensure you have a stable connection to the device
2. Try connecting via USB instead of WiFi
3. Check that the device has sufficient storage space
4. Restart the device and try again

Debugging Connection Issues

If debugging doesn't connect:

1. Verify port 4242 (Swift) or 5678 (Python) is accessible on the device
2. Check that no firewall is blocking the debug ports
3. Ensure the application was started with the --debug flag
4. Try restarting both VS Code and the device

Next Steps

• Connect your device to WiFi for wireless development
• Discover devices using the CLI
• Manage applications on your device