feat(cli): add chat command for accessing interface (#8)

* docs: update name of latest installer exe in download section

* fix(env): add CUDA path and fix quote escaping

* fix(env): add cuda path and fix quote escaping

* feat(cli): add chat command for accessing interface

---------

Co-authored-by: libing0526 <libqtweb@gmail.com>

Author: libing0526

README.md

@@ -44,7 +44,7 @@ Parallax Windows CLI adopts modern C++ design patterns and mainly contains the f
   - Unified command parsing and execution framework
   - Command base class based on template method pattern
   - Support for standardized parameter validation, environment preparation, and execution flow
-- **Supported Commands**: check, install, config, run, join, cmd
+- **Supported Commands**: check, install, config, run, join, chat, cmd
 
 ### 2. Environment Installer
 - **Location**: `src/parallax/environment/`
@@ -133,6 +133,9 @@ parallax check
 
 # Start Parallax inference server (optional)
 parallax run
+
+# Access chat interface (optional)
+parallax chat
 ```
 
 ## Command Reference
@@ -180,6 +183,12 @@ Join distributed inference cluster as a node
 parallax join [args...]
 ```
 
+### `parallax chat`
+Access chat interface from non-scheduler computer
+```cmd
+parallax chat [args...]
+```
+
 ### `parallax cmd`
 Execute commands in WSL or Python virtual environment
 ```cmd
@@ -189,6 +198,7 @@ parallax cmd [--venv] <command> [args...]
 **Command Descriptions**:
 - `run`: Start Parallax inference server directly in WSL. You can pass any arguments supported by `parallax run` command. Examples: `parallax run -m Qwen/Qwen3-0.6B`, `parallax run --port 8080`
 - `join`: Join distributed inference cluster as a worker node. You can pass any arguments supported by `parallax join` command. Examples: `parallax join -m Qwen/Qwen3-0.6B`, `parallax join -s scheduler-addr`
+- `chat`: Access chat interface from any non-scheduler computer. You can pass any arguments supported by `parallax chat` command. Examples: `parallax chat` (local network), `parallax chat -s scheduler-addr` (public network), `parallax chat --host 0.0.0.0` (allow external access). After launching, visit http://localhost:3002 in your browser.
 - `cmd`: Pass-through commands to WSL environment, supports `--venv` option to run in parallax project's Python virtual environment
 
 **Main Configuration Items**:
@@ -291,6 +301,9 @@ parallax config list
 # Start inference server test
 parallax run
 
+# Access chat interface test
+parallax chat
+
 # Execute commands in WSL
 parallax cmd "python --version"
 

src/parallax/cli/command_parser.cpp

@@ -158,6 +158,14 @@ void CommandParser::InitializeBuiltinCommands() {
                         return static_cast<int>(result);
                     });
 
+    // Register chat command (access chat interface from non-scheduler computer)
+    RegisterCommand("chat", "Access chat interface from non-scheduler computer",
+                    [](const std::vector<std::string>& args) -> int {
+                        parallax::commands::ModelChatCommand chat_cmd;
+                        auto result = chat_cmd.Execute(args);
+                        return static_cast<int>(result);
+                    });
+
     // Register cmd command (pass-through command to WSL or virtual environment)
     RegisterCommand("cmd",
                     "Execute commands in WSL or Python virtual environment",

src/parallax/cli/commands/model_commands.cpp

@@ -165,5 +165,96 @@ std::string ModelJoinCommand::BuildJoinCommand(const CommandContext& context) {
     return command_stream.str();
 }
 
+// ModelChatCommand implementation
+CommandResult ModelChatCommand::ValidateArgsImpl(CommandContext& context) {
+    // Check if it's a help request
+    if (context.args.size() == 1 &&
+        (context.args[0] == "--help" || context.args[0] == "-h")) {
+        ShowHelpImpl();
+        return CommandResult::Success;
+    }
+
+    // chat command can be executed without parameters (using default settings)
+    return CommandResult::Success;
+}
+
+CommandResult ModelChatCommand::ExecuteImpl(const CommandContext& context) {
+    // Build chat command: parallax chat [user parameters...]
+    std::string chat_command = BuildChatCommand(context);
+
+    // Build complete WSL command with venv activation and CUDA environment
+    std::string full_command = BuildVenvActivationCommand(context);
+
+    // If proxy is configured, add proxy environment variables
+    if (!context.proxy_url.empty()) {
+        full_command += " && HTTP_PROXY='" + context.proxy_url +
+                        "' HTTPS_PROXY='" + context.proxy_url + "' " +
+                        chat_command;
+    } else {
+        full_command += " && " + chat_command;
+    }
+
+    std::string wsl_command = BuildWSLCommand(context, full_command);
+
+    info_log("Executing chat interface command: %s", wsl_command.c_str());
+
+    // Use WSLProcess to execute command for real-time output
+    WSLProcess wsl_process;
+    int exit_code = wsl_process.Execute(wsl_command);
+
+    if (exit_code == 0) {
+        ShowInfo("Chat interface started successfully. Visit http://localhost:3002 in your browser.");
+        return CommandResult::Success;
+    } else {
+        ShowError("Failed to start chat interface with exit code: " +
+                  std::to_string(exit_code));
+        return CommandResult::ExecutionError;
+    }
+}
+
+void ModelChatCommand::ShowHelpImpl() {
+    std::cout << "Usage: parallax chat [args...]\n\n";
+    std::cout << "Access the chat interface from any non-scheduler computer.\n\n";
+    std::cout << "This command will:\n";
+    std::cout << "  1. Change to ~/parallax directory\n";
+    std::cout << "  2. Activate the Python virtual environment\n";
+    std::cout << "  3. Set proxy environment variables (if configured)\n";
+    std::cout << "  4. Execute 'parallax chat' with your arguments\n";
+    std::cout << "  5. Start chat server at http://localhost:3002\n\n";
+    std::cout << "Arguments:\n";
+    std::cout << "  args...       Arguments to pass to parallax chat "
+                 "(optional)\n\n";
+    std::cout << "Options:\n";
+    std::cout << "  --help, -h    Show this help message\n\n";
+    std::cout << "Examples:\n";
+    std::cout
+        << "  parallax chat                           # Execute: parallax "
+           "chat (local area network)\n";
+    std::cout << "  parallax chat -s scheduler-addr         # Execute: parallax "
+                 "chat -s scheduler-addr (public network)\n";
+    std::cout
+        << "  parallax chat -s 12D3KooWLX7MWuzi1Txa5LyZS4eTQ2tPaJijheH8faHggB9SxnBu\n";
+    std::cout << "                                          # Connect to specific scheduler\n";
+    std::cout << "  parallax chat --host 0.0.0.0           # Allow API access from other machines\n\n";
+    std::cout << "Note: All arguments will be passed to the built-in "
+                 "parallax chat script\n";
+    std::cout << "      in the Parallax Python virtual environment.\n";
+    std::cout << "      After launching, visit http://localhost:3002 in your browser.\n";
+}
+
+std::string ModelChatCommand::BuildChatCommand(const CommandContext& context) {
+    std::ostringstream command_stream;
+
+    // Built-in execution of parallax chat
+    command_stream << "parallax chat";
+
+    // If there are user parameters, append them
+    for (const auto& arg : context.args) {
+        command_stream << " " << EscapeForShell(arg);
+    }
+
+    return command_stream.str();
+}
+
 }  // namespace commands
 }  // namespace parallax

src/parallax/cli/commands/model_commands.h

@@ -126,5 +126,28 @@ class ModelJoinCommand : public WSLCommand<ModelJoinCommand> {
     std::string BuildJoinCommand(const CommandContext& context);
 };
 
+// Chat command - access chat interface from non-scheduler computer
+class ModelChatCommand : public WSLCommand<ModelChatCommand> {
+ public:
+    std::string GetName() const override { return "chat"; }
+    std::string GetDescription() const override {
+        return "Access chat interface from non-scheduler computer";
+    }
+
+    EnvironmentRequirements GetEnvironmentRequirements() {
+        EnvironmentRequirements req;
+        req.need_wsl = true;
+        req.sync_proxy = true;
+        return req;
+    }
+
+    CommandResult ValidateArgsImpl(CommandContext& context);
+    CommandResult ExecuteImpl(const CommandContext& context);
+    void ShowHelpImpl();
+
+ private:
+    std::string BuildChatCommand(const CommandContext& context);
+};
+
 }  // namespace commands
 }  // namespace parallax