[OS]🚀 Introducing BoltWS Companion — A Live Development Companion For Extension Developers! Useful for Bolt, Fast, Rush CLI

Open Source Development Extension Development
1

Hello everyone! 👋

I'm excited to introduce BoltWS Companion, an Android companion project designed to make Kodular and MIT App Inventor extension development easier, faster, and more interactive.

Developing extensions often involves writing Java code, building the extension, testing it, identifying errors, and repeating the process. My goal with BoltWS Companion is to simplify this workflow by bringing extension development and live testing closer together.

The project focuses on connecting your PC-based development workflow with an Android companion, making it easier to experiment with extension methods, parameters, UI components, and runtime behavior.

This is an evolving project, and I want to improve it with feedback and contributions from the community.

⚡ 1. Live Development with Bolt CLI

One of the key goals of BoltWS Companion is to make the live development workflow as convenient as possible.

🔥 Automatic Connection When You Run bolt run

The intended workflow is simple:

  1. Open your extension project on your PC.
  2. Start the Bolt CLI live development workflow using bolt run.
  3. Launch BoltWS Companion on your Android device.
  4. The companion is designed to discover and connect to the PC automatically when the required components and network configuration are ready.
  5. Use the companion to test and inspect supported extension functionality during development.

The main idea is to reduce manual connection steps and make live testing more convenient.

The workflow uses network discovery and WebSocket communication to connect the PC-side development process with the Android companion.

The PC and Android device must be able to communicate over the network, and the required services and permissions must be configured correctly.

⚡ 2. FAST CLI Live Testing Using Node.js

BoltWS Companion also aims to support a live testing workflow for developers using FAST CLI.

In this workflow, a Node.js script running on the PC acts as part of the communication process between the development environment and the Android companion.

The workflow is intended to help developers:

  • Connect the PC-side workflow with the companion.
  • Discover the companion over the local network.
  • Communicate through WebSocket.
  • Send supported development data for live testing.
  • Experiment with extension functionality without relying exclusively on a traditional build-and-test cycle.

🟢 What About the Node.js File?

The FAST workflow uses a Node.js script, such as fast-live.js, for PC-side communication.

How to create the Node.js file, configure it, run it, and connect it to BoltWS Companion will be explained separately.

I want to cover that process in a dedicated guide rather than make this announcement unnecessarily complicated.

Bolt CLI vs. FAST CLI

Feature Bolt CLI FAST CLI
Development workflow Start with bolt run Use the PC-side Node.js workflow
Companion connection Designed for automatic discovery and connection Uses the configured Node.js communication workflow
Communication WebSocket and network discovery Node.js, WebSocket and network discovery
Main objective Simplify live extension development Enable live testing through the FAST workflow

The exact experience depends on the development setup, network configuration, and the functionality supported by the current implementation.

🧩 3. Extension Method and Parameter Testing

Extension development is not just about compiling Java code. Developers also need to understand how methods behave when called with different arguments.

BoltWS Companion is being developed to help with this process.

The intended testing workflow includes inspecting supported methods and experimenting with parameters such as:

  • String — Text values
  • Integer — Whole numbers
  • Float / Double — Decimal values
  • Boolean — True or false
  • Color — Color values
  • View — Android UI view references

The goal is to make method testing more convenient and help developers understand how different parameter values affect runtime behavior.

Support depends on the method, parameter type, and the current implementation.

🛠️ 4. Reflection-Based Method Inspection

Android and Java reflection can help inspect classes and their available methods at runtime.

BoltWS Companion includes a reflection-oriented approach to method inspection and parameter handling.

This can help developers explore extension methods without having to manually write a separate test for every possible method.

The broader objective is to make extension debugging and experimentation easier, especially when developing custom components.

🎨 5. UI Component and View Testing

Android extensions frequently create or modify UI elements dynamically.

Testing these components can be challenging when their appearance or behavior depends on runtime values.

BoltWS Companion aims to make UI-related extension testing more interactive.

Potential testing areas include:

  • Creating and inspecting supported UI components.
  • Experimenting with method parameters.
  • Checking runtime behavior.
  • Testing supported view-related operations.
  • Identifying issues during development.

The goal is to provide developers with a more practical environment for experimenting with their extensions.

▶️ 6. Run and Reset Workflow

A useful development companion should make repeated testing convenient.

BoltWS Companion includes a development-oriented workflow for running supported tests and resetting the testing state.

This is intended to help developers experiment with different values and test scenarios without repeatedly starting the entire process from scratch.

The behavior of individual controls and their compatibility with different components will continue to be improved as the project evolves.

📡 7. Network Communication Architecture

BoltWS Companion uses network communication to connect the Android companion with the PC-side development workflow.

The current project architecture includes:

Component Purpose
UDP — Port 9001 Network discovery
WebSocket — Port 9000 PC-to-companion communication
Android Companion Receives supported development messages and provides the companion-side interface
PC-side scripts and tools Support the development and live-testing workflow
DEX-related workflow Supports the project's extension-development and testing approach

These components are intended to work together to make the development process more interactive.

For successful communication, the PC and Android device must be reachable over the network, and the relevant ports must be accessible.

🧪 8. Why Is This Project Useful?

Traditional extension development often involves a repetitive cycle:

Write code → Build extension → Install or update → Test → Find an issue → Modify code → Build again.

A live development workflow aims to reduce unnecessary repetition and make experimentation more convenient.

BoltWS Companion is intended to help extension developers:

  • Experiment with supported methods and parameters.
  • Test extension behavior during development.
  • Inspect runtime behavior more conveniently.
  • Work with Bolt CLI and FAST CLI development workflows.
  • Identify problems earlier in the development process.
  • Explore new possibilities for extension debugging and testing.

The objective is not to replace every part of the normal extension-building process, but to provide another useful tool for development and experimentation.

🧪 9. Current Testing Status — Honest Feedback Is Welcome

I have tested BoltWS Companion with selected extensions, but I have not yet fully established its complete capabilities, limitations, or compatibility across different extensions and use cases.

I want to be transparent about the current status of the project. Testing a few selected extensions does not mean that every feature has been fully tested or that every type of extension will work correctly.

The full capabilities and limitations of the project are not yet completely clear. More real-world testing is needed to understand what works well, what needs improvement, and what features may be missing.

That's why I would appreciate it if developers could try the project with their own extensions and share their experiences.

Please help me understand:

  • Which features work correctly?
  • Which features do not work as expected?
  • Which extension types or methods cause problems?
  • Are there parameter types that need better support?
  • Are there connection, UI, or runtime issues?
  • What important features are missing?
  • What should be improved first?

Please do not hesitate to report problems or limitations. Honest feedback is more valuable than simply saying that everything works.

Your testing can help reveal the project's actual strengths and weaknesses and guide future improvements.

🗺️ 10. Future Roadmap

BoltWS Companion is an evolving project. There are several areas I would like to explore and improve with community feedback.

🔹 Planned Improvements

1. Better Method and Parameter Metadata

Improve how method names, parameter names, parameter types, and other relevant metadata are obtained and displayed.

2. Better Kodular Block Integration

Explore ways to connect extension metadata with the corresponding Kodular block information so developers can identify methods and parameters more easily.

3. Improved Parameter Handling

Improve support for different parameter types, default values, and more convenient input controls.

4. Better UI and User Experience

Make the companion interface more intuitive, organized, and easier to use during development.

5. Improved Error Handling

Make connection problems, invalid inputs, unsupported methods, and runtime errors easier to identify.

6. More Reliable Live Testing

Continue improving the Bolt CLI and FAST CLI workflows to make the connection and testing process more convenient.

7. Documentation and Tutorials

Provide clearer instructions for setting up the companion, configuring the PC-side tools, and using the supported workflows.

These are areas for future development, not a promise that every feature is already implemented. Their priority will depend on feasibility, testing, and community feedback.

🌍 11. This Is an Open-Source Project — You Can Contribute!

One of the most important things I want to share is that BoltWS Companion is an open-source project released under the MIT License.

I am sharing the source code publicly because I believe projects like this can become more useful when developers work together.

🤝 What Can You Do?

  • Use it: Explore the project and use it in your own development workflow.
  • Modify it: Change the source code to suit your needs.
  • Add new features: Develop new functionality and improvements.
  • Fix bugs: Investigate problems and contribute fixes.
  • Improve the UI: Suggest or implement interface improvements.
  • Improve compatibility: Explore support for additional methods, parameter types, and development workflows.
  • Contribute code: Fork the repository, make improvements, and submit a pull request.
  • Share feedback: Explain what works, what does not work, and what should be improved.

You do not need to wait for me to implement every feature. If you have the knowledge and want to improve something, you can work on the project yourself.

You are welcome to use, modify, and distribute the project in accordance with the MIT License.

🐛 Found a Problem? Please Report It!

If you encounter a bug, connection problem, unexpected behavior, or missing feature, please share the details through the repository's GitHub Issues section.

When reporting a problem, it helps to include:

  • What you were trying to do.
  • The steps required to reproduce the problem.
  • The error message or relevant logs.
  • Whether you were using Bolt CLI or FAST CLI.
  • Any other technical details that may help identify the cause.

Clear reports make it easier to understand problems and work toward solutions.

💡 Have an Idea for a New Feature?

I would also like to hear your suggestions.

If you believe a feature would make BoltWS Companion more useful, describe the idea and explain how it could help extension developers.

I cannot promise that every suggestion will be implemented, but I will consider community feedback and evaluate useful ideas for future development.

The aim is to build something practical that can benefit more than one developer.

🙌 12. Let's Build It Together!

BoltWS Companion is an attempt to make Kodular and MIT App Inventor extension development more convenient through live testing, method inspection, parameter handling, and PC-to-Android communication.

I welcome developers, extension creators, testers, and anyone interested in improving the project.

You can use the source code, modify it, experiment with new ideas, report problems, or contribute improvements.

If something is missing, tell me. If something is broken, report it. If you have a better idea, share it.

We can discuss the problems, evaluate possible solutions, and consider useful improvements for future versions.

Thank you to everyone who takes the time to explore the project and contribute to its development! ❤️

🔗 GitHub Repository — Explore, Use, Modify, and Contribute

The complete source code is available here:

https://github.com/Praveenhajare/BoltWS-Companion

The project is open source under the MIT License. Feel free to explore the code, use it, modify it, add new features, and contribute improvements in accordance with the license.

If you encounter any issues or have suggestions, please share them through GitHub.

Your feedback, testing, and contributions can help identify limitations and shape the project's future.

BoltWS Companion Apk

2 Likes
2

:laptop: FAST CLI & RUSH Extension Live Testing Guide

:play_button:

:rocket: Guide: Live Testing FAST & RUSH CLI Extensions Using BoltWS Companion

Hello Kodular and MIT App Inventor Community! :waving_hand:

I'm sharing a guide explaining how to test FAST CLI extensions using **BoltWS Companion**.

This workflow uses a Node.js helper script called `fast-live.js` to send the compiled extension's DEX binary to the Companion.

:clipboard: 1. Requirements

* Windows PC
* FAST& Rush CLI installed
* Node.js installed
* BoltWS Companion on your Android device
* A FAST /Rush CLI extension project
* PC and Android device connected to the same Wi-Fi network

:file_folder: 2. Add Two JavaScript Files

Place these two files in your FAST project's main folder:

  1. `fast-live.js`

  2. `parameter-metadata.js`

Open zip download js file

Example folder structure:

```
FASTProjects/
├── AbstractShapeCard/
├── NeumorphismUI/
├── fast-live.js
└── parameter-metadata.js
```

Your folder structure may be different.

**Important:** Make sure both files have the correct filenames and are saved in the expected location.

:gear: 3. Install Required Node.js Packages

If the required packages are not already installed, run these commands in the appropriate terminal directory:

```
npm init -y
npm install ws adm-zip
```

If these packages are already installed and working, you do not need to install them again.

:play_button: 4. Start the Live Testing Server

On my PC, the `fast-live.js` file is located at:

```
C:\Users\××××\Desktop\FASTProjects\fast-live.js
```

Therefore, I use this command:

```
node C:\Users\××××\Desktop\FASTProjects\fast-live.js
```

**Important:** This is my PC's path. You must replace it with the actual path to your own `fast-live.js` file.

For example, if your Windows username is `Rahul`, your command might be:

```
node "C:\Users\Rahul\Desktop\FASTProjects\fast-live.js"
```

Here, `Rahul` is only an example. Use your own Windows username and actual folder path.

:warning: Important Instruction

**Keep your FAST /Rush CLI project open and run the command in the appropriate project terminal.**

Make sure the helper script can locate the correct extension's `out` folder.

The command shown above is only an example. Always use the correct path for your own PC.

:satellite_antenna: 5. Check the Server

After running the command successfully, the terminal should display messages indicating that the server has started.

The script uses these ports:

Port Purpose
UDP 9001 PC discovery
WebSocket 9000 Connection and data transfer

Keep the terminal running while testing.

**Note:** Bolt CLI's live server also uses port `9000`. Running both servers on the same port simultaneously may cause a port conflict.

:mobile_phone: 6. Connect BoltWS Companion

  1. Open BoltWS Companion on your Android device.
  2. Make sure your PC and phone are connected to the same Wi-Fi network.
  3. Keep the Node.js helper script running.
  4. Tap **FIND BOLT PC** in the Companion.
  5. Check whether your PC is discovered and connected.
  6. Verify whether the extension appears in the Companion.

:speech_balloon: Community Feedback

I have tested this workflow with selected extensions, but its complete capabilities and limitations have not yet been fully established.

I invite other extension developers to try this workflow and share their feedback.

Please report any connection problems, extension loading issues, or other limitations you encounter.

Useful suggestions will be considered for future improvements, although implementation of every suggestion cannot be guaranteed.

:link: GitHub Repository

Thank you!

4 Likes
3

Confusing, we already have a BOLT CLI development platform?

1 Like
4

Yes, but the way both apps work is different.

5

I do not doubt that, but now we have two extension development platforms called Bolt*

1 Like
6

It appears that BoltWS serves as a companion tool for testing extensions with ease.

1 Like
7

Thanks for your feedback! :blush: Bolt CLI and BoltWS Companion serve different purposes.Bolt CLI is a development platform for creating and building extensions, while BoltWS Companion focuses on live testing and debugging extensions on an Android device.
The goal is to complement existing development tools, not replace Bolt CLI.

8

Exactly! :blush::rocket: BoltWS is designed to make extension testing easier and faster by allowing developers to test their extensions directly on an Android device. Thanks for understanding and sharing your thoughts! :raising_hands:

1 Like