@browsersync/bslive 0.0.7 → 0.0.13

package/Cargo.toml

@@ -1,5 +1,34 @@
-workspace.members = ["bslive"]
+workspace.members = [
+    "bslive",
+    "bsnext",
+    "crates/*"
+]
 workspace.resolver = "2"
 
 [workspace.dependencies]
-tokio = { version = "1.37.0", features = ["full"] }
+clap = { version = "4.5.3", features = ["derive"] }
+axum = { version = "0.7.4", features = ["ws"] }
+tokio = { version = "1", features = ["full"] }
+tokio-stream = { version = "0.1.15", features = ["sync"] }
+futures = "0.3.30"
+futures-util = { version = "0.3", default-features = false, features = ["sink", "std"] }
+tower = { version = "0.4.13" }
+tower-http = { version = "0.5.0", features = ['trace', 'fs', 'compression-full', 'decompression-full', 'catch-panic', 'cors', 'timeout', 'set-header'] }
+tracing = "0.1.40"
+tracing-subscriber = { version = "0.3.18", features = ["env-filter", "json"] }
+actix = "0.13.1"
+actix-rt = "2.9.0"
+anyhow = "1.0.69"
+serde = { version = "1.0.152", features = ["derive"] }
+serde_yaml = "0.9.33"
+serde_json = "1.0.115"
+thiserror = "1.0.58"
+bytes = "1.6.0"
+http = "1.1.0"
+http-body-util = "0.1.1"
+typeshare = "1"
+random_word = { version = "0.4.3", features = ["en"] }
+toml = { version = "0.8.12" }
+mime_guess = "2.0.4"
+tempfile = "3.10.1"
+insta = { version = "1.38.0", features = ["yaml"] }

package/bin.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 console.log('from cli package');
 
-const { start } = require("./index.js");
-start(process.argv.slice(1)).catch(console.error);
+const { startSync } = require("./index.js");
+let r = startSync(process.argv.slice(1));
+console.log(r);

package/bslive/Cargo.toml

@@ -7,10 +7,25 @@ version = "0.0.0"
 crate-type = ["cdylib"]
 
 [dependencies]
+bsnext_core = { path = "../crates/bsnext_core" }
+bsnext_input = { path = "../crates/bsnext_input" }
+bsnext_fs = { path = "../crates/bsnext_fs" }
+bsnext_tracing = { path = "../crates/bsnext_tracing" }
+bsnext_system = { path = "../crates/bsnext_system" }
+bsnext_output = { path = "../crates/bsnext_output" }
+
+clap = { workspace = true }
+tokio = { workspace = true }
+tracing = { workspace = true }
+actix = { workspace = true }
+actix-rt = { workspace = true }
+anyhow = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+
 # Default enable napi4 feature, see https://nodejs.org/api/n-api.html#node-api-version-matrix
 napi = { version = "2.12.2", default-features = false, features = ["napi4", "tokio_rt", "tokio_full"] }
 napi-derive = "2.12.2"
-tokio = { workspace = true }
 
 [build-dependencies]
 napi-build = "2.0.1"

package/bslive/build.rs

@@ -1,5 +1,5 @@
 extern crate napi_build;
 
 fn main() {
-  napi_build::setup();
+    napi_build::setup();
 }

package/bslive/src/lib.rs

@@ -3,12 +3,133 @@
 #[macro_use]
 extern crate napi_derive;
 
+use actix::Actor;
+use std::env::current_dir;
+use std::io::Write;
+use std::path::PathBuf;
 use std::time::Duration;
+
+use clap::Parser;
+
+use bsnext_core::dto::ExternalEvents;
+use bsnext_output::{OutputWriter, Writers};
+use bsnext_system::args::Args;
+use bsnext_system::start_kind::StartKind;
+use bsnext_system::startup::{DidStart, StartupResult};
+use bsnext_system::{BsSystem, Start};
+use bsnext_tracing::{init_tracing, OutputFormat, WriteOption};
+use tokio::sync::{mpsc, oneshot};
 use tokio::time::sleep;
 
 #[napi]
-async fn start(args: Vec<String>) -> napi::bindgen_prelude::Result<i32> {
-  println!("{:?}", args);
-  sleep(Duration::from_secs(2)).await;
-  Ok(32)
+async fn start(_args: Vec<String>) -> napi::bindgen_prelude::Result<i32> {
+    eprintln!("async not supported yet");
+    sleep(Duration::from_secs(2)).await;
+    Ok(32)
+}
+
+/// Launch in a blocking way
+#[napi]
+fn start_sync(args: Vec<String>) -> napi::bindgen_prelude::Result<i32> {
+    let sys = actix_rt::System::new();
+    println!("sync args {:?}", args);
+    std::env::set_var("RUST_LIB_BACKTRACE", "0");
+    let result = sys.block_on(async move {
+        match main_sync(args).await {
+            Ok(_) => 0,
+            Err(e) => {
+                eprintln!("{:?}", e);
+                1
+            }
+        }
+    });
+    Ok(result)
+}
+
+async fn main_sync(args: Vec<String>) -> Result<(), anyhow::Error> {
+    let cwd = PathBuf::from(current_dir().unwrap().to_string_lossy().to_string());
+    let args = Args::parse_from(&args);
+    let format_clone = args.format;
+
+    let write_opt = if args.write_log {
+        WriteOption::File
+    } else {
+        WriteOption::None
+    };
+    init_tracing(args.log_level, args.format, write_opt);
+    tracing::debug!("{:#?}", args);
+
+    let (tx, rx) = oneshot::channel();
+    let (startup_oneshot_sender, startup_oneshot_receiver) = oneshot::channel::<StartupResult>();
+    let (events_sender, mut events_receiver) = mpsc::channel::<ExternalEvents>(1);
+
+    let system = BsSystem::new();
+    let sys_addr = system.start();
+
+    let start_kind = StartKind::from_args(args);
+
+    let start = Start {
+        kind: start_kind,
+        cwd: Some(cwd),
+        ack: tx,
+        events_sender,
+        startup_oneshot_sender,
+    };
+
+    sys_addr.do_send(start);
+
+    match startup_oneshot_receiver.await {
+        Ok(Ok(DidStart::Started)) => tracing::info!("started..."),
+        Ok(Err(e)) => return Err(e.into()),
+        Err(e) => return Err(e.into()),
+    };
+
+    let events_handler = tokio::spawn(async move {
+        let events = vec![];
+        let stdout = &mut std::io::stdout();
+        let printer = match format_clone {
+            None | Some(OutputFormat::Normal) => Writers::Pretty,
+            Some(OutputFormat::Json) => Writers::Json,
+        };
+        while let Some(evt) = events_receiver.recv().await {
+            match printer.handle_event(stdout, &evt) {
+                Ok(_v) => {}
+                Err(e) => tracing::error!("could not write to stdout {e}"),
+            }
+            match stdout.flush() {
+                Ok(_) => {}
+                Err(e) => tracing::error!("could not flush {e}"),
+            };
+        }
+        events
+    });
+
+    match rx.await {
+        Ok(_) => {
+            tracing::info!("servers ended");
+        }
+        Err(e) => {
+            // dropped? this is ok
+            tracing::trace!(?e, "");
+        }
+    };
+
+    match events_handler.await {
+        Ok(v) => {
+            tracing::info!(?v, "events seen");
+            let errors = v
+                .iter()
+                .filter(|e| matches!(e, ExternalEvents::StartupFailed(..)))
+                .collect::<Vec<_>>();
+            if !errors.is_empty() {
+                tracing::info!("stopped for the following reasons");
+                for msg in errors {
+                    tracing::error!(?msg);
+                }
+                return Err(anyhow::anyhow!("exited..."));
+            }
+        }
+        Err(e) => tracing::error!(?e),
+    }
+    Ok(())
 }

package/bsnext/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "bsnext"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+bsnext_core = { path = "../crates/bsnext_core" }
+bsnext_input = { path = "../crates/bsnext_input" }
+bsnext_fs = { path = "../crates/bsnext_fs" }
+bsnext_tracing = { path = "../crates/bsnext_tracing" }
+bsnext_system = { path = "../crates/bsnext_system" }
+bsnext_output = { path = "../crates/bsnext_output" }
+
+clap = { workspace = true }
+tokio = { workspace = true }
+tracing = { workspace = true }
+actix = { workspace = true }
+actix-rt = { workspace = true }
+anyhow = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }

package/bsnext/src/main.rs

@@ -0,0 +1,116 @@
+use actix::Actor;
+use std::env::current_dir;
+use std::io::Write;
+use std::path::PathBuf;
+
+use bsnext_core::dto::ExternalEvents;
+use bsnext_output::{OutputWriter, Writers};
+use bsnext_system::args::Args;
+use bsnext_system::start_kind::StartKind;
+use bsnext_system::startup::{DidStart, StartupResult};
+use bsnext_system::{BsSystem, Start};
+use bsnext_tracing::{init_tracing, OutputFormat, WriteOption};
+use clap::Parser;
+use tokio::sync::{mpsc, oneshot};
+
+#[actix_rt::main]
+async fn main() -> Result<(), anyhow::Error> {
+    std::env::set_var("RUST_LIB_BACKTRACE", "0");
+    let cwd = PathBuf::from(current_dir().unwrap().to_string_lossy().to_string());
+    let args = Args::parse();
+    let format_clone = args.format;
+    let write_opt = if args.write_log {
+        WriteOption::File
+    } else {
+        WriteOption::None
+    };
+
+    init_tracing(args.log_level, args.format, write_opt);
+    tracing::debug!("{:#?}", args);
+
+    let (tx, rx) = oneshot::channel();
+    let (startup_oneshot_sender, startup_oneshot_receiver) = oneshot::channel::<StartupResult>();
+    let (events_sender, mut events_receiver) = mpsc::channel::<ExternalEvents>(1);
+
+    let system = BsSystem::new();
+    let sys_addr = system.start();
+
+    let start_kind = StartKind::from_args(args);
+
+    let start = Start {
+        kind: start_kind,
+        cwd: Some(cwd),
+        ack: tx,
+        events_sender,
+        startup_oneshot_sender,
+    };
+
+    sys_addr.do_send(start);
+
+    match startup_oneshot_receiver.await? {
+        Ok(DidStart::Started) => tracing::info!("started..."),
+        Err(e) => return Err(e.into()),
+    };
+
+    let events_handler = tokio::spawn(async move {
+        let events = vec![];
+        let stdout = &mut std::io::stdout();
+        let printer = match format_clone {
+            None | Some(OutputFormat::Normal) => Writers::Pretty,
+            Some(OutputFormat::Json) => Writers::Json,
+        };
+        while let Some(evt) = events_receiver.recv().await {
+            tracing::debug!(external_event=?evt);
+            match printer.handle_event(stdout, &evt) {
+                Ok(_v) => {}
+                Err(e) => tracing::error!("could not write to stdout {e}"),
+            }
+            match stdout.flush() {
+                Ok(_) => {}
+                Err(e) => tracing::error!("could not flush {e}"),
+            };
+            // let as_evt = ExternalEvent {
+            //     level: EventLevel::External,
+            //     fields: evt,
+            // };
+            // let json = serde_json::to_string_pretty(&as_evt).unwrap();
+            // println!("{json}");
+            // match handle_event(stdout, &evt) {
+            //     Ok(_) => {
+            //         events.push(evt);
+            //     }
+            //     Err(e) => tracing::error!("could not write to stdout {e}"),
+            // }
+        }
+        events
+    });
+
+    match rx.await {
+        Ok(_) => {
+            tracing::info!("servers ended");
+        }
+        Err(e) => {
+            // dropped? this is ok
+            tracing::trace!(?e, "");
+        }
+    };
+
+    match events_handler.await {
+        Ok(v) => {
+            tracing::info!(?v, "events seen");
+            let errors = v
+                .iter()
+                .filter(|e| matches!(e, ExternalEvents::StartupFailed(..)))
+                .collect::<Vec<_>>();
+            if !errors.is_empty() {
+                tracing::info!("stopped for the following reasons");
+                for msg in errors {
+                    tracing::error!(?msg);
+                }
+                return Err(anyhow::anyhow!("exited..."));
+            }
+        }
+        Err(e) => tracing::error!(?e),
+    }
+    Ok(())
+}

package/crates/bsnext_client/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "bsnext_client"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

package/crates/bsnext_client/build.rs

@@ -0,0 +1,53 @@
+use std::env::current_dir;
+use std::io::Write;
+use std::process::Command;
+use std::{env, io};
+
+fn main() {
+    if env::var("CI").is_ok() {
+        return;
+    }
+    let curr = current_dir().expect("current dir");
+    let root = curr
+        .parent()
+        .expect("parent")
+        .parent()
+        .expect("parent 2")
+        .to_path_buf();
+    let output = Command::new("typeshare")
+        .args([
+            "crates/bsnext_core",
+            "--lang=typescript",
+            "--output-file=crates/bsnext_client/generated/dto.ts",
+        ])
+        .current_dir(&root)
+        .output()
+        .expect("build types");
+
+    io::stdout().write_all(&output.stdout).unwrap();
+    io::stderr().write_all(&output.stderr).unwrap();
+
+    assert!(output.status.success());
+
+    let output = Command::new("npm")
+        .args(["run", "schema"])
+        .current_dir(root.join("crates").join("bsnext_client"))
+        .output()
+        .expect("build schema");
+
+    io::stdout().write_all(&output.stdout).unwrap();
+    io::stderr().write_all(&output.stderr).unwrap();
+
+    assert!(output.status.success());
+
+    let output = Command::new("npm")
+        .args(["run", "build"])
+        .current_dir(root.join("crates").join("bsnext_client"))
+        .output()
+        .expect("sh command failed to start");
+
+    io::stdout().write_all(&output.stdout).unwrap();
+    io::stderr().write_all(&output.stderr).unwrap();
+
+    assert!(output.status.success());
+}

package/crates/bsnext_client/generated/dto.ts

@@ -0,0 +1,147 @@
+/*
+ Generated by typeshare 1.9.2
+*/
+
+export type RouteKindDTO = 
+	| { kind: "Html", payload: {
+	html: string;
+}}
+	| { kind: "Json", payload: {
+	json_str: string;
+}}
+	| { kind: "Raw", payload: {
+	raw: string;
+}}
+	| { kind: "Sse", payload: {
+	sse: string;
+}}
+	| { kind: "Proxy", payload: {
+	proxy: string;
+}}
+	| { kind: "Dir", payload: {
+	dir: string;
+}};
+
+export interface RouteDTO {
+	path: string;
+	kind: RouteKindDTO;
+}
+
+export interface ServerDesc {
+	routes: RouteDTO[];
+	id: string;
+}
+
+export type IdentityDTO = 
+	| { kind: "Both", payload: {
+	name: string;
+	bind_address: string;
+}}
+	| { kind: "Address", payload: {
+	bind_address: string;
+}}
+	| { kind: "Named", payload: {
+	name: string;
+}};
+
+export interface ServerDTO {
+	id: string;
+	identity: IdentityDTO;
+	socket_addr: string;
+}
+
+export interface GetServersMessageResponse {
+	servers: ServerDTO[];
+}
+
+export type ServerChange = 
+	| { kind: "Stopped", payload: {
+	bind_address: string;
+}}
+	| { kind: "Started", payload?: undefined }
+	| { kind: "Patched", payload?: undefined };
+
+export interface ServerChangeSetItem {
+	identity: IdentityDTO;
+	change: ServerChange;
+}
+
+export interface ServerChangeSet {
+	items: ServerChangeSetItem[];
+}
+
+export interface ServersStarted {
+	servers_resp: GetServersMessageResponse;
+	changeset: ServerChangeSet;
+}
+
+export enum EventLevel {
+	External = "BSLIVE_EXTERNAL",
+}
+
+export type ExternalEvents = 
+	| { kind: "ServersStarted", payload: ServersStarted }
+	| { kind: "Watching", payload: Watching }
+	| { kind: "WatchingStopped", payload: StoppedWatching }
+	| { kind: "FileChanged", payload: FileChanged }
+	| { kind: "FilesChanged", payload: FilesChangedDTO }
+	| { kind: "InputFileChanged", payload: FileChanged }
+	| { kind: "InputAccepted", payload: InputAccepted }
+	| { kind: "StartupFailed", payload: InputErrorDTO };
+
+export interface ExternalEvent {
+	level: EventLevel;
+	fields: ExternalEvents;
+}
+
+export interface InputAccepted {
+	path: string;
+}
+
+export interface FileChanged {
+	path: string;
+}
+
+export interface FilesChangedDTO {
+	paths: string[];
+}
+
+export interface DebounceDTO {
+	kind: string;
+	ms: string;
+}
+
+export interface Watching {
+	paths: string[];
+	debounce: DebounceDTO;
+}
+
+export interface StoppedWatching {
+	paths: string[];
+}
+
+export type InputErrorDTO = 
+	| { kind: "MissingInputs", payload: string }
+	| { kind: "InvalidInput", payload: string }
+	| { kind: "NotFound", payload: string }
+	| { kind: "InputWriteError", payload: string }
+	| { kind: "PathError", payload: string }
+	| { kind: "PortError", payload: string }
+	| { kind: "DirError", payload: string };
+
+export type ClientEvent = 
+	| { kind: "Change", payload: ChangeDTO };
+
+export type ChangeDTO = 
+	| { kind: "Fs", payload: {
+	path: string;
+	change_kind: ChangeKind;
+}}
+	| { kind: "FsMany", payload: ChangeDTO[] };
+
+export enum ChangeKind {
+	Changed = "Changed",
+	Added = "Added",
+	Removed = "Removed",
+}
+