command-stream 0.9.2 → 0.9.4

package/js/docs/case-studies/issue-144/README.md

@@ -0,0 +1,215 @@
+# Case Study: Windows CI Test Failures (Issue #144)
+
+## Summary
+
+This document provides a comprehensive analysis of the Windows test failures in the command-stream library's CI pipeline, including timeline of events, root causes, and proposed solutions.
+
+## Timeline of Events
+
+### December 27, 2025
+
+1. **14:53:56 UTC** - PR #143 created to transition to new CI/CD template with modern best practices
+2. **15:12:12 UTC** - First commit with Windows tests enabled in CI matrix
+3. **15:12:26 UTC** - First Windows test failures detected (Run ID: 20540726833)
+4. **15:17:47 UTC** - macOS and Windows tests temporarily disabled due to platform issues
+5. **15:20:13 UTC** - macOS tests were re-enabled after symlink resolution fixes
+6. **16:03:39 UTC** - Cross-platform CI re-enabled, but Windows tests fail again
+7. **16:13:42 UTC** - Windows tests disabled again pending path separator fixes
+8. **16:24:10 UTC** - PR #143 merged with Windows tests disabled
+9. **18:17:18 UTC** - Issue #144 created to track Windows CI fixes
+
+## Test Execution Results (Windows)
+
+From CI Run 20541247679 (2025-12-27T16:03:52Z):
+
+| Metric      | Count   |
+| ----------- | ------- |
+| Total tests | 647     |
+| Passed      | 595     |
+| Failed      | 47      |
+| Skipped     | 5       |
+| Errors      | 2       |
+| Duration    | 175.88s |
+
+### Success Rate: 91.96% (595/647)
+
+## Root Cause Analysis
+
+### Primary Issue: Shell Detection Failure
+
+The core problem is that the `findAvailableShell()` function in `src/$.mjs` only looks for Unix-style shells:
+
+```javascript
+const shellsToTry = [
+  { cmd: '/bin/sh', args: ['-l', '-c'], checkPath: true },
+  { cmd: '/usr/bin/sh', args: ['-l', '-c'], checkPath: true },
+  { cmd: '/bin/bash', args: ['-l', '-c'], checkPath: true },
+  // ... more Unix paths
+  { cmd: 'sh', args: ['-l', '-c'], checkPath: false },
+  { cmd: 'bash', args: ['-l', '-c'], checkPath: false },
+];
+```
+
+On Windows, these paths don't exist, leading to:
+
+```
+ENOENT: no such file or directory, uv_spawn 'sh'
+```
+
+### Secondary Issues
+
+1. **Path Separator Differences**
+   - Windows uses backslashes (`\`) vs Unix forward slashes (`/`)
+   - Some tests with hardcoded paths fail due to this mismatch
+
+2. **Signal Handling (SIGINT)**
+   - Windows handles process signals differently than Unix
+   - CTRL+C behavior is platform-specific
+   - Many signal-related tests timeout or fail
+
+3. **Temp Directory Paths**
+   - Windows uses `C:\Users\RUNNER~1\AppData\Local\Temp\` format
+   - Short path notation (8.3) can cause issues with path matching
+
+4. **Timing Differences**
+   - Windows process spawning is slower
+   - Test expectations like `expect(timeToFirstChunk).toBeLessThan(50)` fail
+   - Actual value: 366ms vs expected <50ms
+
+## Failed Tests Categories
+
+### Category 1: Shell Spawn Failures (ENOENT 'sh')
+
+- ProcessRunner Options > should handle cwd option
+- Synchronous Execution (.sync()) > Options in Sync Mode > should handle cwd option
+- Start/Run Options Passing > .start() method with options > should work with real shell commands
+- Options Examples (Feature Demo) > example: real shell command vs virtual command
+- And many more shell-dependent tests
+
+### Category 2: Path/CD Command Issues
+
+- cd Virtual Command - Command Chains > should persist directory change within command chain
+- cd Virtual Command - Edge Cases > should handle cd with trailing slash
+- cd Virtual Command - Edge Cases > should handle cd with multiple slashes
+- Virtual Commands System > Built-in Commands > should execute virtual cd command
+
+### Category 3: Signal Handling Timeouts
+
+- CTRL+C Signal Handling > should forward SIGINT to child process
+- CTRL+C Different stdin Modes > should handle CTRL+C with string stdin
+- CTRL+C with Different stdin Modes > should bypass virtual commands with custom stdin
+- streaming interfaces - kill method works
+
+### Category 4: Timing-Sensitive Tests
+
+- command-stream Feature Validation > Real-time Streaming > should stream data as it arrives
+
+### Category 5: Platform-Specific Commands
+
+- Built-in Commands > Command Location (which) > which should find existing system commands
+- System Command Piping (Issue #8) > Piping to sort > should pipe to sort for sorting lines
+
+## Proposed Solutions
+
+### Solution 1: Add Windows Shell Detection (Required)
+
+Add Windows shells to `findAvailableShell()`:
+
+```javascript
+const shellsToTry = [
+  // Windows shells (check first on Windows)
+  ...(process.platform === 'win32'
+    ? [
+        { cmd: 'cmd.exe', args: ['/c'], checkPath: false },
+        { cmd: 'powershell.exe', args: ['-Command'], checkPath: false },
+        { cmd: 'pwsh.exe', args: ['-Command'], checkPath: false },
+        // Git Bash (most compatible)
+        {
+          cmd: 'C:\\Program Files\\Git\\bin\\bash.exe',
+          args: ['-c'],
+          checkPath: true,
+        },
+        {
+          cmd: 'C:\\Program Files\\Git\\usr\\bin\\bash.exe',
+          args: ['-c'],
+          checkPath: true,
+        },
+      ]
+    : []),
+  // Unix shells
+  { cmd: '/bin/sh', args: ['-l', '-c'], checkPath: true },
+  // ... rest of Unix shells
+];
+```
+
+### Solution 2: Path Normalization Helper
+
+Create a cross-platform path normalization function:
+
+```javascript
+function normalizePath(p) {
+  if (process.platform === 'win32') {
+    // Convert forward slashes to backslashes for Windows
+    // Handle UNC paths and drive letters
+    return path.normalize(p);
+  }
+  return p;
+}
+```
+
+### Solution 3: Skip/Adjust Platform-Specific Tests
+
+Add platform checks to inherently Unix-specific tests:
+
+```javascript
+test.skipIf(process.platform === 'win32')(
+  'should forward SIGINT...',
+  async () => {
+    // Unix-specific signal handling
+  }
+);
+```
+
+### Solution 4: Increase Timing Tolerances
+
+Adjust timing expectations for Windows:
+
+```javascript
+const MAX_FIRST_CHUNK_TIME = process.platform === 'win32' ? 500 : 50;
+expect(timeToFirstChunk).toBeLessThan(MAX_FIRST_CHUNK_TIME);
+```
+
+## Recommendation
+
+Given the complexity of full Windows support, I recommend a phased approach:
+
+### Phase 1: Quick Wins (This PR)
+
+1. Add basic Windows shell detection with Git Bash fallback
+2. Skip tests that are fundamentally incompatible with Windows
+3. Document Windows limitations in README
+
+### Phase 2: Future Work
+
+1. Implement full cross-platform path handling
+2. Add Windows-specific virtual command implementations
+3. Create Windows-specific test configurations
+
+## Files Changed/To Be Changed
+
+| File                            | Change Type | Description                     |
+| ------------------------------- | ----------- | ------------------------------- |
+| `src/$.mjs`                     | Modified    | Add Windows shell detection     |
+| `tests/*.test.mjs`              | Modified    | Add platform-specific skips     |
+| `.github/workflows/release.yml` | Modified    | Re-enable Windows in CI matrix  |
+| `README.md`                     | Modified    | Document Windows support status |
+
+## References
+
+- GitHub Actions Run: https://github.com/link-foundation/command-stream/actions/runs/20541247679
+- PR #143: https://github.com/link-foundation/command-stream/pull/143
+- Issue #144: https://github.com/link-foundation/command-stream/issues/144
+
+## Appendix: Full Failure List
+
+See `failures-summary.md` for the complete list of 47 failed tests with error details.

package/js/docs/case-studies/issue-144/failures-summary.md

@@ -0,0 +1,161 @@
+# Windows CI Test Failures - Detailed Summary
+
+Run ID: 20541247679
+Date: 2025-12-27T16:03:52Z
+Platform: Windows Server 2025 (10.0.26100)
+Bun Version: 1.3.5
+
+## Complete List of 47 Failed Tests
+
+### 1. Shell/Spawn Failures (ENOENT 'sh')
+
+These failures occur because Windows doesn't have `sh` in the PATH by default:
+
+| Test                                                                                                     | Duration | Error                                             |
+| -------------------------------------------------------------------------------------------------------- | -------- | ------------------------------------------------- |
+| command-stream Feature Validation > Real-time Streaming > should stream data as it arrives, not buffered | 406ms    | Timing expectation failed (366ms > 50ms expected) |
+| ProcessRunner Options > should handle cwd option                                                         | -        | ENOENT: no such file or directory, uv_spawn 'sh'  |
+| Synchronous Execution (.sync()) > Options in Sync Mode > should handle cwd option                        | -        | ENOENT: no such file or directory, uv_spawn 'sh'  |
+
+### 2. Command Detection Issues
+
+| Test                                                                                                         | Duration | Error                    |
+| ------------------------------------------------------------------------------------------------------------ | -------- | ------------------------ |
+| Built-in Commands (Bun.$ compatible) > Command Location (which) > which should find existing system commands | -        | System command not found |
+| String interpolation fix for Bun > Shell operators in interpolated commands should work                      | -        | Shell execution failure  |
+| Bun-specific shell path tests > Bun.spawn compatibility is maintained                                        | -        | Shell not found          |
+
+### 3. CD Virtual Command Failures
+
+Path handling and quoting issues on Windows:
+
+| Test                                                                                       | Duration | Error                        |
+| ------------------------------------------------------------------------------------------ | -------- | ---------------------------- |
+| cd Virtual Command - Command Chains > should persist directory change within command chain | 32ms     | Path resolution failure      |
+| cd Virtual Command - Command Chains > should handle multiple cd commands in chain          | 31ms     | Path resolution failure      |
+| cd Virtual Command - Command Chains > should work with git commands in chain               | 31ms     | Path resolution failure      |
+| cd Virtual Command - Edge Cases > should handle cd with trailing slash                     | 32ms     | ENOENT with quoted paths     |
+| cd Virtual Command - Edge Cases > should handle cd with multiple slashes                   | 31ms     | ENOENT with multiple slashes |
+| Virtual Commands System > Built-in Commands > should execute virtual cd command            | 31ms     | Path handling failure        |
+
+Specific error example:
+
+```
+ENOENT: no such file or directory, chdir 'D:\a\command-stream\command-stream\' -> ''C:\Users\RUNNER~1\AppData\Local\Temp\cd-slash-NXM4ex'/'
+```
+
+### 4. SIGINT/Signal Handling Failures
+
+Windows handles signals differently than Unix:
+
+| Test                                                                                                            | Duration | Error                     |
+| --------------------------------------------------------------------------------------------------------------- | -------- | ------------------------- |
+| CTRL+C Baseline Tests (Native Spawn) > should handle Node.js inline script with SIGINT                          | 531ms    | Signal handling failure   |
+| CTRL+C Baseline Tests (Native Spawn) > should handle Node.js script file                                        | 1015ms   | Signal handling failure   |
+| CTRL+C Different stdin Modes > should handle CTRL+C with string stdin                                           | 5015ms   | **TIMEOUT**               |
+| CTRL+C Different stdin Modes > should handle CTRL+C with Buffer stdin                                           | 5016ms   | **TIMEOUT**               |
+| CTRL+C Signal Handling > should forward SIGINT to child process when external CTRL+C is sent                    | 3000ms   | Signal not forwarded      |
+| CTRL+C Signal Handling > should not interfere with user SIGINT handling when no children active                 | 547ms    | Handler conflict          |
+| CTRL+C Signal Handling > should not interfere with child process signal handlers                                | 1031ms   | Handler conflict          |
+| CTRL+C with Different stdin Modes > should bypass virtual commands with custom stdin for proper signal handling | 547ms    | Signal handling failure   |
+| CTRL+C with Different stdin Modes > should handle Bun vs Node.js signal differences                             | 1047ms   | Platform difference       |
+| CTRL+C with Different stdin Modes > should properly cancel virtual commands and respect user SIGINT handlers    | 547ms    | Handler cleanup issue     |
+| SIGINT Cleanup Tests (Isolated) > should forward SIGINT to child processes                                      | 547ms    | Signal forwarding failure |
+
+### 5. Git/GH Command Integration Failures
+
+| Test                                                                                                                                          | Duration | Error                 |
+| --------------------------------------------------------------------------------------------------------------------------------------------- | -------- | --------------------- |
+| Git and GH commands with cd virtual command > Git operations in temp directories > should handle git commands in temp directory with cd chain | 31ms     | Path resolution       |
+| Git and GH commands with cd virtual command > Git operations in temp directories > should handle git branch operations with cd                | 31ms     | Path resolution       |
+| Git and GH commands with cd virtual command > Git operations in temp directories > should handle multiple temp directories with cd            | 47ms     | Path resolution       |
+| Git and GH commands with cd virtual command > Git operations in temp directories > should handle git diff operations after cd                 | 47ms     | Path resolution       |
+| Git and GH commands with cd virtual command > Combined git and gh workflows > should simulate solve.mjs workflow pattern                      | 5047ms   | **TIMEOUT**           |
+| Git and GH commands with cd virtual command > Combined git and gh workflows > should preserve cwd after command chains                        | 1015ms   | CWD not preserved     |
+| Git and GH commands with cd virtual command > Combined git and gh workflows > should work with complex git workflows using operators          | 31ms     | Operator failure      |
+| Git and GH commands with cd virtual command > Path resolution and quoting with cd > should handle paths with spaces in git operations         | 32ms     | Quote handling        |
+| Git and GH commands with cd virtual command > Path resolution and quoting with cd > should handle special characters in paths                 | 31ms     | Special char escaping |
+
+### 6. GitHub CLI (gh) Failures
+
+| Test                                                                                              | Duration | Error           |
+| ------------------------------------------------------------------------------------------------- | -------- | --------------- |
+| GitHub CLI (gh) commands > gh auth status returns correct exit code and output structure          | 5047ms   | **TIMEOUT**     |
+| Examples Execution Tests > should not interfere with user SIGINT handling when no children active | 500ms    | Signal handling |
+
+### 7. jq Streaming Failures
+
+| Test                                                                                      | Duration | Error         |
+| ----------------------------------------------------------------------------------------- | -------- | ------------- |
+| jq streaming tests > stream of JSON objects through jq -c                                 | 1015ms   | Pipe handling |
+| jq streaming tests > generate and process array elements as stream                        | 782ms    | Pipe handling |
+| jq streaming with pipe \| syntax > stream of JSON objects through jq -c using pipe syntax | 140ms    | Pipe syntax   |
+| jq streaming with pipe \| syntax > process array elements as stream using pipe syntax     | 110ms    | Pipe syntax   |
+
+### 8. Shell Feature Failures
+
+| Test                                                                                                                     | Duration | Error             |
+| ------------------------------------------------------------------------------------------------------------------------ | -------- | ----------------- |
+| Shell Settings (set -e / set +e equivalent) > Shell Replacement Benefits > should provide better error objects than bash | 125ms    | Shell differences |
+| Cleanup Verification > should not affect cwd when cd is in subshell                                                      | 406ms    | Subshell handling |
+| Options Examples (Feature Demo) > example: real shell command vs virtual command                                         | 16ms     | Shell not found   |
+
+### 9. Output/Streaming Failures
+
+| Test                                                                                                     | Duration | Error               |
+| -------------------------------------------------------------------------------------------------------- | -------- | ------------------- |
+| Start/Run Edge Cases and Advanced Usage > should work with real shell commands that produce large output | -        | Shell spawn failure |
+| Start/Run Options Passing > .start() method with options > should work with real shell commands          | 16ms     | Shell spawn failure |
+| Stderr output handling in $.mjs > long-running commands with stderr output should not hang               | 812ms    | Stream handling     |
+| streaming interfaces - kill method works                                                                 | 5015ms   | **TIMEOUT**         |
+
+### 10. System Command Piping Failures
+
+| Test                                                                                      | Duration | Error                    |
+| ----------------------------------------------------------------------------------------- | -------- | ------------------------ |
+| System Command Piping (Issue #8) > Piping to sort > should pipe to sort for sorting lines | 16ms     | sort command differences |
+| System Command Piping (Issue #8) > Piping to sort > should handle sort with reverse flag  | 16ms     | sort -r differences      |
+
+## Key Error Messages
+
+### ENOENT Shell Spawn
+
+```
+ENOENT: no such file or directory, uv_spawn 'sh'
+    path: "sh",
+ syscall: "uv_spawn",
+   errno: -4058,
+    code: "ENOENT"
+```
+
+### Path Resolution with Quotes
+
+```
+ENOENT: no such file or directory, chdir 'D:\a\command-stream\command-stream\' -> ''C:\Users\RUNNER~1\AppData\Local\Temp\cd-slash-NXM4ex'/'
+```
+
+### Signal Handling
+
+```
+kill() failed: ESRCH: no such process
+```
+
+## Statistics
+
+- **Total failures: 47**
+- **Timeout failures: 6** (tests that exceeded 5000ms limit)
+- **ENOENT failures: ~20** (shell not found)
+- **Signal handling failures: ~11**
+- **Path/CD failures: ~10**
+
+## Environment Details
+
+```
+Platform: win32
+OS: Microsoft Windows Server 2025 10.0.26100
+Runner: GitHub Actions windows-latest (windows-2025)
+Bun: 1.3.5+1e86cebd7
+Git: 2.52.0.windows.1
+PowerShell: 7.x available
+Git Bash: Available at C:\Program Files\Git\bin\bash.exe
+```

package/js/docs/case-studies/issue-146/README.md

@@ -0,0 +1,244 @@
+# Case Study: JavaScript to Rust Translation (Issue #146)
+
+## Summary
+
+This document provides a comprehensive analysis of the process, challenges, and lessons learned from translating the command-stream JavaScript library to Rust.
+
+## Project Overview
+
+### Original JavaScript Codebase
+
+- **Main file**: `src/$.mjs` (~6,765 lines)
+- **Shell parser**: `src/shell-parser.mjs` (~403 lines)
+- **Utilities**: `src/$.utils.mjs` (~101 lines)
+- **Virtual commands**: 21 command files in `src/commands/`
+- **Total**: ~8,400 lines of JavaScript
+
+### Rust Translation
+
+- **Main library**: `rust/src/lib.rs`
+- **Shell parser**: `rust/src/shell_parser.rs`
+- **Utilities**: `rust/src/utils.rs`
+- **Virtual commands**: 21 command modules in `rust/src/commands/`
+
+## Timeline of Development
+
+### Phase 1: Code Organization
+
+1. Created `js/` folder structure to house JavaScript code
+2. Updated `package.json` to point to new `js/src/` location
+3. Updated all import statements in tests and examples
+
+### Phase 2: Rust Project Setup
+
+1. Created `rust/` folder with Cargo.toml
+2. Defined dependencies:
+   - `tokio` for async runtime
+   - `which` for command lookup
+   - `nix` for Unix signal handling
+   - `regex` for pattern matching
+   - `chrono` for timestamps
+   - `filetime` for file timestamp operations
+
+### Phase 3: Core Translation
+
+1. Translated shell parser (tokenizer, parser, AST types)
+2. Translated utilities (tracing, command results, ANSI handling)
+3. Translated main library (ProcessRunner, shell detection)
+4. Translated all 21 virtual commands
+
+## Key Translation Patterns
+
+### 1. JavaScript Async to Rust Async
+
+**JavaScript:**
+
+```javascript
+async function sleep({ args, abortSignal }) {
+  const seconds = parseFloat(args[0] || 0);
+  await new Promise((resolve) => setTimeout(resolve, seconds * 1000));
+  return { stdout: '', code: 0 };
+}
+```
+
+**Rust:**
+
+```rust
+pub async fn sleep(ctx: CommandContext) -> CommandResult {
+    let seconds: f64 = ctx.args.first()
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(0.0);
+
+    tokio::time::sleep(Duration::from_secs_f64(seconds)).await;
+    CommandResult::success_empty()
+}
+```
+
+### 2. JavaScript Object Literals to Rust Structs
+
+**JavaScript:**
+
+```javascript
+const result = {
+  stdout: output,
+  stderr: '',
+  code: 0,
+  async text() {
+    return this.stdout;
+  },
+};
+```
+
+**Rust:**
+
+```rust
+#[derive(Debug, Clone)]
+pub struct CommandResult {
+    pub stdout: String,
+    pub stderr: String,
+    pub code: i32,
+}
+
+impl CommandResult {
+    pub fn success(stdout: impl Into<String>) -> Self {
+        CommandResult {
+            stdout: stdout.into(),
+            stderr: String::new(),
+            code: 0,
+        }
+    }
+}
+```
+
+### 3. JavaScript Closures to Rust Trait Objects
+
+**JavaScript:**
+
+```javascript
+function trace(category, messageOrFunc) {
+  const message =
+    typeof messageOrFunc === 'function' ? messageOrFunc() : messageOrFunc;
+  console.error(`[TRACE] [${category}] ${message}`);
+}
+```
+
+**Rust:**
+
+```rust
+pub fn trace_lazy<F>(category: &str, message_fn: F)
+where
+    F: FnOnce() -> String,
+{
+    if !is_trace_enabled() {
+        return;
+    }
+    trace(category, &message_fn());
+}
+```
+
+### 4. JavaScript Error Handling to Rust Result Types
+
+**JavaScript:**
+
+```javascript
+try {
+  const content = fs.readFileSync(path, 'utf8');
+  return { stdout: content, code: 0 };
+} catch (error) {
+  if (error.code === 'ENOENT') {
+    return { stderr: `cat: ${file}: No such file or directory`, code: 1 };
+  }
+  throw error;
+}
+```
+
+**Rust:**
+
+```rust
+match fs::read_to_string(&path) {
+    Ok(content) => CommandResult::success(content),
+    Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
+        CommandResult::error(format!("cat: {}: No such file or directory\n", file))
+    }
+    Err(e) => CommandResult::error(format!("cat: {}: {}\n", file, e)),
+}
+```
+
+## Challenges Encountered
+
+### 1. Tagged Template Literals
+
+JavaScript's tagged template literal syntax `$\`echo hello\``has no direct Rust equivalent. We implemented the`$()` function as a regular function call instead.
+
+### 2. Event Emitter Pattern
+
+JavaScript's EventEmitter pattern required translation to Rust's channel-based communication using `tokio::sync::mpsc`.
+
+### 3. Process Group Handling
+
+Unix process group management differs between Node.js and Rust. We used the `nix` crate for proper signal handling.
+
+### 4. Async Iterator Pattern
+
+JavaScript's `for await (const chunk of stream)` was translated to Rust's async stream patterns using channels.
+
+## Lessons Learned
+
+### 1. Type Safety Benefits
+
+Rust's type system caught several edge cases that existed in the JavaScript code:
+
+- Null/undefined handling became explicit with `Option<T>`
+- Error handling became explicit with `Result<T, E>`
+- String encoding issues were caught at compile time
+
+### 2. Memory Management
+
+Rust's ownership model required explicit decisions about:
+
+- When to clone vs borrow data
+- Lifetime of process handles
+- Cleanup of resources on cancellation
+
+### 3. Cross-Platform Considerations
+
+Both JavaScript and Rust require platform-specific code for:
+
+- Shell detection (Windows vs Unix)
+- Signal handling (SIGINT, SIGTERM)
+- File permissions
+
+### 4. Testing Strategy
+
+Unit tests were essential for:
+
+- Verifying parity with JavaScript behavior
+- Catching edge cases early
+- Documenting expected behavior
+
+## Architecture Comparison
+
+| Component       | JavaScript             | Rust                    |
+| --------------- | ---------------------- | ----------------------- |
+| Async Runtime   | Node.js/Bun event loop | Tokio                   |
+| Process Spawn   | child_process.spawn    | tokio::process::Command |
+| Channels        | EventEmitter           | mpsc channels           |
+| Error Handling  | try/catch              | Result<T, E>            |
+| String Handling | UTF-16 strings         | UTF-8 String            |
+| File I/O        | fs module              | std::fs                 |
+| Signal Handling | process.on('SIGINT')   | tokio::signal           |
+
+## Future Improvements
+
+1. **Streaming Improvements**: Implement async iterator traits for better streaming support
+2. **Error Types**: Create more specific error types for different failure modes
+3. **Performance**: Benchmark and optimize critical paths
+4. **Platform Support**: Add more Windows-specific implementations
+5. **CI/CD**: Add Rust builds to existing CI pipeline
+
+## References
+
+- Original Issue: https://github.com/link-foundation/command-stream/issues/146
+- Pull Request: https://github.com/link-foundation/command-stream/pull/147
+- Rust Book: https://doc.rust-lang.org/book/
+- Tokio Documentation: https://tokio.rs/