fsv 0.1.2

fsv
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

# fsv (File Share Viewer)

`fsv` is a fast, lightweight, and modern command-line application built in Rust and Preact. It allows you to quickly share a local file or directory over HTTP and interact with connected clients via WebSockets in real-time.

## Features

- **Static File Serving & Downloads**: Share local files or entire directories instantly.
- **Built-in Modern Web UI**: Features a beautiful glassmorphic frontend built with Preact and Vite. The entire UI is bundled into a single standalone HTML file inside the binary.
- **WebSocket Broadcasting**: Push real-time messages to all connected Web UI clients directly from the CLI control shell.
- **Secure File Access**: Includes built-in protection against directory traversal attacks.
- **Standalone Binary & Library**: Can be run as a CLI tool or integrated into other Rust applications as a library.

## Building from Source

Ensure you have Rust and Node.js (with `npm`) installed.

1. First, build the frontend Web UI:
   ```bash
   npm run build
   ```
   *This compiles the Preact application in the `ui/` directory and generates a single `dist/index.html` file.*

2. Build the Rust backend server:
   ```bash
   cargo build --release
   ```

## Usage

Start the server by specifying the path you want to share. By default, it will host on port `8888`.

```bash
# Share the current directory
fsv .

# Share a specific directory on a custom port
fsv /path/to/share -p 8080
```

Once started, `fsv` will print the available access links. You can open any of the Web UI links in your browser to view the files.

### Interactive Control Shell

While the server is running, you can use the built-in command prompt (`fsv>`) to control the application:

- `broadcast <message>`: Sends a real-time message to all active WebSocket clients. The message will appear instantly on the Web UI feed.
- `stop` (or `exit`): Gracefully shuts down the server.
- `help`: Displays available commands.

## Using as a Library

You can easily integrate the core server logic into your own Rust projects by disabling the `cli` feature to drop CLI-specific dependencies (like `clap`).

Add the following to your `Cargo.toml`:

```toml
[dependencies]
fsv = { path = "path/to/fsv", default-features = false }
```

Then, you can programmatically start the server:

```rust
use fsv::{Config, run};
use std::path::PathBuf;

#[tokio::main]
async fn main() {
    let config = Config {
        path: PathBuf::from("."),
        port: 8080,
    };
    
    // Start the server in the background
    let (ips, port, handle) = run(config).await.unwrap();
    println!("Server running on port: {}", port);
    
    // Broadcast a message programmatically
    handle.send_message("Hello from the library code!").unwrap();
}
```

## License

This project is licensed under the MIT License.