refactor: remove daemon, scheduler, and frontend

Remove flowctl-daemon (3130 LOC), flowctl-scheduler, and frontend/ (15587 files).
These are unnecessary with JSON file storage — CLI is the sole interface.

Stub daemon transport in approval.rs (returns None).
Remove hyper/axum/tower-http/notify/bytes deps from CLI.

Net: -11,275 lines. 243 tests pass.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: z23cc

flowctl/Cargo.lock

@@ -3,10 +3,8 @@ resolver = "2"
 members = [
     "crates/flowctl-core",
     "crates/flowctl-db",
-    "crates/flowctl-scheduler",
     "crates/flowctl-service",
     "crates/flowctl-cli",
-    "crates/flowctl-daemon",
 ]
 
 # ── Shared package metadata (nushell convention) ──────────────────────
@@ -57,16 +55,10 @@ clap = { version = "4", features = ["derive"] }
 clap_complete = "4"
 miette = { version = "7", features = ["fancy"] }
 
-# Async runtime (daemon + scheduler)
+# Async runtime (service layer)
 tokio = { version = "1", features = ["full"] }
 tokio-util = { version = "0.7", features = ["rt"] }
 
-# HTTP (daemon)
-axum = { version = "0.8", features = ["ws"] }
-
-# File watching (daemon)
-notify = "7"
-
 # Unix process management
 nix = { version = "0.30", features = ["signal", "process"] }
 
@@ -79,7 +71,6 @@ trycmd = "0.15"
 # Internal crate references
 flowctl-core = { path = "crates/flowctl-core" }
 flowctl-db = { path = "crates/flowctl-db" }
-flowctl-scheduler = { path = "crates/flowctl-scheduler" }
 flowctl-service = { path = "crates/flowctl-service" }
 
 # ── Release profile (size-optimized) ─────────────────────────────────

flowctl/Cargo.toml

@@ -10,19 +10,11 @@ license.workspace = true
 name = "flowctl"
 path = "src/main.rs"
 
-[features]
-default = ["daemon"]
-daemon = ["dep:flowctl-daemon", "dep:axum", "dep:tower-http"]
-
 [dependencies]
 flowctl-core = { workspace = true }
 flowctl-db = { workspace = true }
 flowctl-service = { workspace = true }
 libsql = { workspace = true }
-flowctl-scheduler = { workspace = true }
-flowctl-daemon = { path = "../flowctl-daemon", features = ["daemon"], optional = true }
-axum = { workspace = true, optional = true }
-tower-http = { version = "0.6", features = ["fs"], optional = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 anyhow = { workspace = true }
@@ -36,10 +28,6 @@ regex = { workspace = true }
 sha2 = { workspace = true }
 thiserror = { workspace = true }
 which = { workspace = true }
-hyper = { version = "1", features = ["client", "http1"] }
-hyper-util = { version = "0.1", features = ["client", "client-legacy", "tokio", "http1"] }
-http-body-util = "0.1"
-bytes = "1"
 
 [dev-dependencies]
 trycmd = { workspace = true }

flowctl/crates/flowctl-cli/Cargo.toml

@@ -198,90 +198,23 @@ async fn daemon_request(
     TransportResult::Unreachable
 }
 
+/// Daemon removed — transport stubs return None.
 async fn unix_socket_request(
-    socket_path: &Path,
-    method: &str,
-    path: &str,
-    body: Option<&Value>,
+    _socket_path: &Path,
+    _method: &str,
+    _path: &str,
+    _body: Option<&Value>,
 ) -> Option<TransportResult> {
-    use http_body_util::{BodyExt, Full};
-    use hyper_util::rt::TokioIo;
-
-    let stream = tokio::net::UnixStream::connect(socket_path).await.ok()?;
-    let io = TokioIo::new(stream);
-    let (mut sender, conn) = hyper::client::conn::http1::handshake(io).await.ok()?;
-    tokio::spawn(async move {
-        let _ = conn.await;
-    });
-
-    let body_bytes = match body {
-        Some(v) => serde_json::to_vec(v).ok()?,
-        None => Vec::new(),
-    };
-
-    let req = hyper::Request::builder()
-        .method(method)
-        .uri(path)
-        .header("host", "localhost")
-        .header("content-type", "application/json")
-        .body(Full::new(bytes::Bytes::from(body_bytes)))
-        .ok()?;
-
-    let resp = sender.send_request(req).await.ok()?;
-    let status = resp.status().as_u16();
-    let collected = resp.into_body().collect().await.ok()?.to_bytes();
-    let json_body: Value = if collected.is_empty() {
-        Value::Null
-    } else {
-        serde_json::from_slice(&collected).ok()?
-    };
-    Some(TransportResult::Response {
-        status,
-        body: json_body,
-    })
+    None // No daemon
 }
 
 async fn tcp_request(
-    port: u16,
-    method: &str,
-    path: &str,
-    body: Option<&Value>,
+    _port: u16,
+    _method: &str,
+    _path: &str,
+    _body: Option<&Value>,
 ) -> Option<TransportResult> {
-    use http_body_util::{BodyExt, Full};
-    use hyper_util::rt::TokioIo;
-
-    let stream = tokio::net::TcpStream::connect(("127.0.0.1", port)).await.ok()?;
-    let io = TokioIo::new(stream);
-    let (mut sender, conn) = hyper::client::conn::http1::handshake(io).await.ok()?;
-    tokio::spawn(async move {
-        let _ = conn.await;
-    });
-
-    let body_bytes = match body {
-        Some(v) => serde_json::to_vec(v).ok()?,
-        None => Vec::new(),
-    };
-
-    let req = hyper::Request::builder()
-        .method(method)
-        .uri(path)
-        .header("host", format!("127.0.0.1:{port}"))
-        .header("content-type", "application/json")
-        .body(Full::new(bytes::Bytes::from(body_bytes)))
-        .ok()?;
-
-    let resp = sender.send_request(req).await.ok()?;
-    let status = resp.status().as_u16();
-    let collected = resp.into_body().collect().await.ok()?.to_bytes();
-    let json_body: Value = if collected.is_empty() {
-        Value::Null
-    } else {
-        serde_json::from_slice(&collected).ok()?
-    };
-    Some(TransportResult::Response {
-        status,
-        body: json_body,
-    })
+    None // No daemon
 }
 
 // ── Direct-DB fallback ──────────────────────────────────────────────

flowctl/crates/flowctl-cli/src/commands/approval.rs

@@ -414,14 +414,6 @@ enum Commands {
         shell: Shell,
     },
 
-    // ── Daemon ───────────────────────────────────────────────────────
-    /// Start the daemon process (HTTP API + scheduler + event bus).
-    #[cfg(feature = "daemon")]
-    Serve {
-        /// Port override (default: Unix socket).
-        #[arg(long)]
-        port: Option<u16>,
-    },
 
 }
 
@@ -575,114 +567,6 @@ fn main() {
             generate(shell, &mut cmd, "flowctl", &mut std::io::stdout());
         }
 
-        // Daemon
-        #[cfg(feature = "daemon")]
-        Commands::Serve { port } => {
-            let rt = tokio::runtime::Runtime::new().expect("Failed to create tokio runtime");
-            rt.block_on(async {
-                let cwd = std::env::current_dir().unwrap_or_else(|_| std::path::PathBuf::from("."));
-                let flow_dir = cwd.join(flowctl_core::types::FLOW_DIR);
-                if !flow_dir.exists() {
-                    eprintln!("error: .flow/ does not exist. Run 'flowctl init' first.");
-                    std::process::exit(1);
-                }
-
-                let paths = flowctl_daemon::lifecycle::DaemonPaths::new(&flow_dir);
-                if let Err(e) = paths.ensure_state_dir() {
-                    eprintln!("error: failed to create state dir: {e}");
-                    std::process::exit(1);
-                }
-
-                // Acquire PID lock.
-                if let Err(e) = flowctl_daemon::lifecycle::acquire_pid_lock(&paths) {
-                    eprintln!("error: {e}");
-                    std::process::exit(1);
-                }
-
-                // Clean up orphaned socket from previous run.
-                let _ = flowctl_daemon::lifecycle::cleanup_orphaned_socket(&paths);
-
-                let runtime = flowctl_daemon::lifecycle::DaemonRuntime::new(paths.clone());
-                let cancel = runtime.cancel.clone();
-
-                let (event_bus, _critical_rx) = flowctl_scheduler::EventBus::with_default_capacity();
-
-                // Start notification listener (sound + webhook).
-                let notif_config = flowctl_daemon::notifications::load_config(&flow_dir);
-                let notif_rx = event_bus.subscribe();
-                flowctl_daemon::notifications::spawn_listener(
-                    &runtime.tracker,
-                    notif_rx,
-                    notif_config,
-                );
-
-                // Handle Ctrl+C.
-                let cancel_clone = cancel.clone();
-                tokio::spawn(async move {
-                    tokio::signal::ctrl_c().await.ok();
-                    eprintln!("\nShutting down daemon...");
-                    cancel_clone.cancel();
-                });
-
-                let result = if let Some(tcp_port) = port {
-                    println!("flowctl daemon starting on http://127.0.0.1:{tcp_port}");
-
-                    // Build API router from daemon.
-                    let (state, cancel) = flowctl_daemon::server::create_state(runtime, event_bus)
-                        .await
-                        .expect("failed to create state");
-                    let api_router = flowctl_daemon::server::build_router(state);
-
-                    // Serve static frontend from frontend/dist/ if it exists,
-                    // with SPA fallback to index.html for non-API routes.
-                    use axum::response::IntoResponse;
-                    let dist_dir = cwd.join("frontend").join("dist");
-                    let router = if dist_dir.exists() {
-                        let index_path = dist_dir.join("index.html");
-                        let spa_fallback = axum::routing::get(move || {
-                            let path = index_path.clone();
-                            async move {
-                                match tokio::fs::read_to_string(&path).await {
-                                    Ok(html) => axum::response::Html(html).into_response(),
-                                    Err(_) => axum::http::StatusCode::NOT_FOUND.into_response(),
-                                }
-                            }
-                        });
-                        api_router
-                            .fallback_service(
-                                tower_http::services::ServeDir::new(&dist_dir)
-                                    .not_found_service(spa_fallback),
-                            )
-                    } else {
-                        api_router
-                    };
-
-                    let addr = format!("127.0.0.1:{tcp_port}");
-                    let listener = tokio::net::TcpListener::bind(&addr).await
-                        .expect("failed to bind TCP");
-
-                    axum::serve(listener, router)
-                        .with_graceful_shutdown(async move {
-                            cancel.cancelled().await;
-                        })
-                        .await
-                        .map_err(|e| anyhow::anyhow!("{e}"))
-                } else {
-                    println!("flowctl daemon starting on {}", paths.socket_file.display());
-                    flowctl_daemon::server::serve(runtime, event_bus).await
-                };
-
-                if let Err(e) = result {
-                    eprintln!("daemon error: {e}");
-                    std::process::exit(1);
-                }
-
-                // Cleanup.
-                let _ = std::fs::remove_file(&paths.socket_file);
-                let _ = std::fs::remove_file(&paths.pid_file);
-                println!("daemon stopped.");
-            });
-        }
 
     }
 }