Merge branch 'feature/decouple-build' into development

Author: setoelkahfi

.agents/plans/deploy-modularization.md

@@ -0,0 +1,78 @@
+# Plan: decouple build/deploy from the CLI into `smbcloud-deploy`
+
+Status: in progress. Stages 0 to 3 (vite_spa slice) shipped. Remaining work below
+is the **next milestone**.
+
+## Goal
+
+Move the deploy logic out of `crates/cli` into a reusable `crates/smbcloud-deploy`
+engine so the CLI, the CI action, and (later) the server-side git receiver all
+drive the same code. They differ only in how they report progress and how they
+authenticate.
+
+Two inversions make it reusable:
+- `Reporter` replaces direct `spinners` / `dialoguer` / `println!`, so the engine
+  never owns the terminal. The CLI supplies `SpinnerReporter`.
+- Auth is passed in (a token / credentials); the engine never reads `~/.smb` or
+  prompts for login.
+
+Decisions already made:
+- Networking crates (`smbcloud-networking*`) stay direct deps of the engine.
+  Only reporting and auth are inverted.
+- `git.rs` (SSH-git remote setup) stays in the CLI for now. It is the SSH-git
+  path slated for replacement by git-smart-HTTP, so decoupling it is wasted work.
+- Interactive setup (`setup*.rs`, `process_migrate.rs`) stays in the CLI. It is
+  UX, not engine.
+
+## Done
+
+- **Stage 0** engine crate: `error::DeployError`, `report::{Reporter, NoopReporter}`,
+  `runner::detect_runner`.
+- **Stage 1** CLI depends on the engine; `ui/reporter.rs::SpinnerReporter`;
+  `detect_runner` rewired; old `deploy/detect_runner.rs` removed.
+- **Stage 2** transport: `transport::{Transport, RsyncTransport}` + moved
+  `known_hosts`. CLI helper `deploy::rsync_transport(config, runner, user_id)`
+  resolves the local `~/.ssh` identity and remote path.
+- **Stage 3 (vite_spa slice)** build split: `build::{BuildStrategy, BuildArtifact,
+  ViteSpaBuild}`. `process_deploy_vite_spa.rs` now calls the engine for the build
+  and reuses one `SpinnerReporter` for build + transport.
+
+## Next milestone
+
+### 1. Shared remote-command step
+
+Several strategies do the same "SSH in and restart the service" step, inlined
+per file. Extract it into the engine first (e.g. `transport::RemoteCommand` or a
+`remote` module) so the strategies can share it. Model it behind the same pinned
+host-key SSH used by `RsyncTransport`.
+
+### 2. Remaining `BuildStrategy` extractions (one per pass, compile-green each)
+
+Do smallest first. Each: lift build mechanics into a `BuildStrategy`, swap
+`spinners` + `stop_and_persist` for `Reporter`, take auth as a param, route the
+remote-restart step through step 1.
+
+| File | Lines | Shape |
+| --- | --- | --- |
+| `process_deploy_rails.rs` | ~395 | rsync shared lib, SSH compile native gem, git force-push |
+| `process_deploy_rust.rs` | ~641 | cross-build Linux binary, rsync, SSH restart |
+| `process_deploy_nextjs_ssr.rs` | ~700 | install, build, upload `.next/standalone`, SSH restart |
+| `process_deploy_swift.rs` | ~832 | Docker Linux build, rsync binary + Resources, SSH restart |
+
+Follow `ViteSpaBuild` as the template. Keep the deployment-record API calls
+(`create_deployment` / `update`) in the CLI router, not the engine.
+
+### 3. Stage 4: router + retire the CommandResult wart
+
+- Flip `process_deploy.rs`'s router to call an `engine::deploy(...)` orchestrator.
+- Retire `CommandResult`'s `spinner: Spinner` field (the "return a live spinner,
+  caller stops it" pattern) now that the engine reports the whole flow through
+  `Reporter`. `CommandResult` has ~50 construction sites, so this is its own pass:
+  either make `spinner` optional or drop it and have commands return plain data.
+
+## Reference
+
+- Spec: `smbcloud` repo `.agents/specs/smbcloud-deploy.md` (product direction),
+  `smbcloud-actions.md` (CI wrapper). Direction is git-smart-HTTP, local-first
+  build, drop SSH transport later.
+- Engine crate: `crates/smbcloud-deploy/`.

Cargo.lock

@@ -28,6 +28,7 @@ serde_json = "1.0.82"
 serde_repr = "0.1"
 smbcloud-auth = { version = "0.4.7", path = "crates/smbcloud-auth" }
 smbcloud-auth-sdk = { version = "0.4.7", path = "crates/smbcloud-auth-sdk" }
+smbcloud-deploy = { version = "0.4.7", path = "crates/smbcloud-deploy" }
 smbcloud-email-sdk = { version = "0.4.7", path = "crates/smbcloud-email-sdk" }
 smbcloud-gresiq-sdk = { version = "0.4.7", path = "crates/smbcloud-gresiq-sdk" }
 smbcloud-mail = { version = "0.4.7", path = "crates/smbcloud-mail" }

Cargo.toml

@@ -118,4 +118,4 @@ For the broader product, see [smbCloud](https://smbcloud.xyz/) and the [deployme
 
 ## Copyright
 
-© 2026 [smbCloud](https://smbcloud.xyz) (Splitfire AB).
+© 2026 [Splitfire AB](https://5mb.app) ([smbCloud](https://smbcloud.xyz)).

README.MD

@@ -44,6 +44,7 @@ serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 serde_repr = { workspace = true }
 smbcloud-auth = { workspace = true }
+smbcloud-deploy = { workspace = true }
 smbcloud-mail = { workspace = true }
 smbcloud-model = { workspace = true }
 smbcloud-network = { workspace = true }

crates/cli/Cargo.toml

@@ -99,4 +99,4 @@ More CLI and deployment guides live in the [smbCloud docs](https://smbcloud.xyz/
 
 ## Copyright
 
-© 2026 [smbCloud](https://smbcloud.xyz) (Splitfire AB).
+© 2026 [Splitfire AB](https://5mb.app) ([smbCloud](https://smbcloud.xyz)).

crates/cli/README.md

@@ -1,7 +1,5 @@
 pub mod config;
-mod detect_runner;
 mod git;
-mod known_hosts;
 pub mod process_deploy;
 pub mod process_deploy_nextjs_ssr;
 pub mod process_deploy_rails;
@@ -10,7 +8,43 @@ pub mod process_deploy_swift;
 pub mod process_deploy_vite_spa;
 pub mod process_migrate;
 mod remote_messages;
-pub(crate) mod rsync_deploy;
 pub(crate) mod setup_create_new_project;
 pub(crate) mod setup_project;
 pub(crate) mod setup_select_project;
+
+use {
+    anyhow::{anyhow, Result},
+    smbcloud_deploy::RsyncTransport,
+    smbcloud_model::runner::Runner,
+    smbcloud_utils::config::Config,
+};
+
+// The pinned host keys live in the engine crate. Re-export them here so the
+// strategy modules that build their own pinned-SSH commands can keep using
+// `deploy::known_hosts`.
+pub(crate) use smbcloud_deploy::known_hosts;
+
+/// Build the rsync transport for the current project.
+///
+/// This resolves the front-end-specific bits the engine deliberately doesn't
+/// know about: the server host (from the runner), the remote path (from config,
+/// defaulting to `apps/web/<name>`), and the user's local SSH identity file.
+pub(crate) fn rsync_transport(
+    config: &Config,
+    runner: &Runner,
+    user_id: i32,
+) -> Result<RsyncTransport> {
+    let home = dirs::home_dir().ok_or_else(|| anyhow!("Could not determine home directory"))?;
+    let identity_file = home.join(".ssh").join(format!("id_{user_id}@smbcloud"));
+
+    let remote_path = match &config.project.path {
+        Some(path) => path.clone(),
+        None => format!("apps/web/{}", config.project.name),
+    };
+
+    Ok(RsyncTransport::new(
+        runner.rsync_host(),
+        remote_path,
+        identity_file,
+    ))
+}

crates/cli/src/deploy/detect_runner.rs

@@ -5,15 +5,13 @@ use {
         client,
         deploy::{
             config::{check_project, credentials, get_config, overlay_server_config},
-            detect_runner::detect_runner,
             git::remote_deployment_setup,
             process_deploy_nextjs_ssr::process_deploy_nextjs_ssr,
             process_deploy_rails::process_deploy_rails,
             process_deploy_rust::process_deploy_rust,
             process_deploy_swift::process_deploy_swift,
             process_deploy_vite_spa::process_deploy_vite_spa,
             remote_messages::{build_next_app, start_server},
-            rsync_deploy::rsync_deploy,
         },
         token::{get_smb_token::get_smb_token, is_logged_in::is_logged_in},
         ui::{fail_message, succeed_message, succeed_symbol},
@@ -22,6 +20,7 @@ use {
     dialoguer::{console::Term, theme::ColorfulTheme, Select},
     git2::{PushOptions, RemoteCallbacks, Repository},
     smbcloud_auth::me::me,
+    smbcloud_deploy::Transport,
     smbcloud_model::{
         project::{DeploymentMethod, DeploymentPayload, DeploymentStatus},
         runner::Runner,
@@ -171,7 +170,25 @@ pub async fn process_deploy(
             // detection needed, the source tree may have no package.json/Gemfile/etc.
             let runner = config.project.runner;
             let user = me(env, client(), &access_token).await?;
-            rsync_deploy(&config, &runner, user.id, ".")
+            let transport = crate::deploy::rsync_transport(&config, &runner, user.id)?;
+
+            // The engine ships silently; this command owns the spinner and the
+            // final line it hands back to `main` to persist.
+            let spinner = Spinner::new(
+                spinners::Spinners::Hamburger,
+                succeed_message(&format!("Syncing to {}…", runner.rsync_host())),
+            );
+            match transport.ship(std::path::Path::new("."), &smbcloud_deploy::NoopReporter) {
+                Ok(()) => Ok(CommandResult {
+                    spinner,
+                    symbol: succeed_symbol(),
+                    msg: succeed_message("Deployment complete via rsync."),
+                }),
+                Err(e) => {
+                    drop(spinner);
+                    Err(anyhow!(fail_message(&format!("{e}"))))
+                }
+            }
         }
         DeploymentMethod::Git => git_deploy(env, &access_token, config).await,
     }
@@ -184,7 +201,8 @@ async fn git_deploy(
 ) -> Result<CommandResult> {
     // Runner detection requires framework files (package.json, Gemfile, etc.) —
     // only needed for the git push path where the server builds the project.
-    let runner = detect_runner(&config).await?;
+    let reporter = crate::ui::reporter::SpinnerReporter::new();
+    let runner = smbcloud_deploy::detect_runner(&config, &reporter)?;
     // Check remote repository setup.
     let repo = match Repository::open(".") {
         Ok(repo) => repo,