feat: add db and multi-archive web UI foundation (#8)

* Add SQLite metadata database support

* Implement archive metadata database

* chore: let's guess cargoHash because there's something wrong with nixpkgs!

* Gate test-only database helpers behind cfg(test)

* Fix archive database row identity

* Use serde for archive metadata JSON

* Finalize archive runs at command level

* Handle archive command errors without panics

* Cover tweet entry metadata recording

* Document static regex invariants

* docs: add web UI design spec

* docs: add web UI implementation plan

* chore: move cli into workspace crate

* chore: track workspace crates directory

* refactor: extract archive core crate

* refactor: add core archive opening APIs

* refactor: rename taxonomy model to tags

* feat: add archive query APIs

* feat: add web server registry

* feat: expose archive server APIs

* feat: add archive table web UI

* fix: complete web UI smoke path

* docs: add architecture mental model

* docs: remove private superpowers plans

* nix: split cli and server packages

* chore: remove PLAN.md

crates/archivr-server/src/main.rs

@@ -0,0 +1,20 @@
+mod registry;
+mod routes;
+
+use anyhow::Result;
+use std::{net::SocketAddr, path::PathBuf};
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    let config_path = std::env::args()
+        .nth(1)
+        .map(PathBuf::from)
+        .unwrap_or_else(|| PathBuf::from("archivr-server.toml"));
+    let registry = registry::load_registry(&config_path)?;
+    let app = routes::app(registry);
+    let addr = SocketAddr::from(([127, 0, 0, 1], 8080));
+    let listener = tokio::net::TcpListener::bind(addr).await?;
+    println!("archivr-server listening on http://{addr}");
+    axum::serve(listener, app).await?;
+    Ok(())
+}

crates/archivr-server/src/registry.rs

@@ -0,0 +1,111 @@
+use anyhow::{Context, Result, bail};
+use serde::{Deserialize, Serialize};
+use std::{
+    fs,
+    path::{Path, PathBuf},
+};
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct MountedArchive {
+    pub id: String,
+    pub label: String,
+    pub archive_path: PathBuf,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq)]
+pub struct ServerRegistry {
+    pub archives: Vec<MountedArchive>,
+}
+
+pub fn load_registry(path: &Path) -> Result<ServerRegistry> {
+    let contents = fs::read_to_string(path)
+        .with_context(|| format!("failed to read server registry {}", path.display()))?;
+    let registry = toml::from_str::<ServerRegistry>(&contents)
+        .with_context(|| format!("failed to parse server registry {}", path.display()))?;
+    validate_registry(&registry)?;
+    Ok(registry)
+}
+
+#[cfg(test)]
+pub fn save_registry(path: &Path, registry: &ServerRegistry) -> Result<()> {
+    validate_registry(registry)?;
+    let contents = toml::to_string_pretty(registry)?;
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+    fs::write(path, contents)?;
+    Ok(())
+}
+
+pub fn validate_registry(registry: &ServerRegistry) -> Result<()> {
+    let mut ids = std::collections::HashSet::new();
+    for archive in &registry.archives {
+        if archive.id.trim().is_empty() {
+            bail!("archive id must not be empty");
+        }
+        if !ids.insert(archive.id.as_str()) {
+            bail!("duplicate archive id: {}", archive.id);
+        }
+        if !archive.archive_path.ends_with(".archivr") {
+            bail!(
+                "mounted archive path must point at a .archivr directory: {}",
+                archive.archive_path.display()
+            );
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn registry_round_trips_archives_from_toml() {
+        let temp = tempfile::tempdir().unwrap();
+        let archive_path = temp.path().join("personal").join(".archivr");
+        fs::create_dir_all(&archive_path).unwrap();
+        fs::write(archive_path.join("name"), "Personal").unwrap();
+        fs::write(
+            archive_path.join("store_path"),
+            temp.path().join("store").display().to_string(),
+        )
+        .unwrap();
+
+        let registry = ServerRegistry {
+            archives: vec![MountedArchive {
+                id: "personal".to_string(),
+                label: "Personal".to_string(),
+                archive_path: archive_path.clone(),
+            }],
+        };
+        let path = temp.path().join("server.toml");
+        save_registry(&path, &registry).unwrap();
+
+        let loaded = load_registry(&path).unwrap();
+
+        assert_eq!(loaded, registry);
+    }
+
+    #[test]
+    fn registry_rejects_duplicate_archive_ids() {
+        let registry = ServerRegistry {
+            archives: vec![
+                MountedArchive {
+                    id: "personal".to_string(),
+                    label: "Personal".to_string(),
+                    archive_path: PathBuf::from("/tmp/a/.archivr"),
+                },
+                MountedArchive {
+                    id: "personal".to_string(),
+                    label: "Duplicate".to_string(),
+                    archive_path: PathBuf::from("/tmp/b/.archivr"),
+                },
+            ],
+        };
+
+        let err = validate_registry(&registry).unwrap_err().to_string();
+
+        assert!(err.contains("duplicate archive id"));
+    }
+}

crates/archivr-server/src/routes.rs

@@ -0,0 +1,168 @@
+use std::{path::PathBuf, sync::Arc};
+
+use archivr_core::{archive, database};
+use axum::{
+    Json, Router,
+    extract::{Path, State},
+    http::StatusCode,
+    response::{IntoResponse, Response},
+    routing::get,
+};
+use tower_http::services::{ServeDir, ServeFile};
+
+use crate::registry::{MountedArchive, ServerRegistry};
+
+#[derive(Clone)]
+pub struct AppState {
+    registry: Arc<ServerRegistry>,
+}
+
+pub fn app(registry: ServerRegistry) -> Router {
+    let state = AppState {
+        registry: Arc::new(registry),
+    };
+    let static_dir = static_dir();
+
+    Router::new()
+        .route("/health", get(|| async { "ok" }))
+        .route("/api/archives", get(list_archives))
+        .route("/api/archives/:archive_id/entries", get(list_entries))
+        .route(
+            "/api/archives/:archive_id/entries/:entry_uid",
+            get(entry_detail),
+        )
+        .route("/api/archives/:archive_id/runs", get(list_runs))
+        .nest_service("/assets", ServeDir::new(&static_dir))
+        .fallback_service(ServeFile::new(static_dir.join("index.html")))
+        .with_state(state)
+}
+
+fn static_dir() -> PathBuf {
+    std::env::var_os("ARCHIVR_STATIC_DIR")
+        .map(PathBuf::from)
+        .unwrap_or_else(|| PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("static"))
+}
+
+async fn list_archives(State(state): State<AppState>) -> Json<Vec<MountedArchive>> {
+    Json(state.registry.archives.clone())
+}
+
+async fn list_entries(
+    State(state): State<AppState>,
+    Path(archive_id): Path<String>,
+) -> Result<Json<Vec<archive::EntrySummary>>, ApiError> {
+    let mounted = mounted_archive(&state, &archive_id)?;
+    let conn = database::open_or_initialize(&mounted.archive_path)?;
+    Ok(Json(archive::list_root_entries(&conn)?))
+}
+
+async fn entry_detail(
+    State(state): State<AppState>,
+    Path((archive_id, entry_uid)): Path<(String, String)>,
+) -> Result<Json<archive::EntryDetail>, ApiError> {
+    let mounted = mounted_archive(&state, &archive_id)?;
+    let conn = database::open_or_initialize(&mounted.archive_path)?;
+    let detail = archive::get_entry_detail(&conn, &entry_uid)?
+        .ok_or(ApiError::not_found("entry not found"))?;
+    Ok(Json(detail))
+}
+
+async fn list_runs(
+    State(state): State<AppState>,
+    Path(archive_id): Path<String>,
+) -> Result<Json<Vec<archive::RunSummary>>, ApiError> {
+    let mounted = mounted_archive(&state, &archive_id)?;
+    let conn = database::open_or_initialize(&mounted.archive_path)?;
+    Ok(Json(archive::list_runs(&conn)?))
+}
+
+fn mounted_archive<'a>(
+    state: &'a AppState,
+    archive_id: &str,
+) -> Result<&'a MountedArchive, ApiError> {
+    state
+        .registry
+        .archives
+        .iter()
+        .find(|archive| archive.id == archive_id)
+        .ok_or(ApiError::not_found("archive not found"))
+}
+
+#[derive(Debug)]
+pub struct ApiError {
+    status: StatusCode,
+    message: String,
+}
+
+impl ApiError {
+    fn not_found(message: &str) -> Self {
+        Self {
+            status: StatusCode::NOT_FOUND,
+            message: message.to_string(),
+        }
+    }
+}
+
+impl<E> From<E> for ApiError
+where
+    E: Into<anyhow::Error>,
+{
+    fn from(error: E) -> Self {
+        let error = error.into();
+        Self {
+            status: StatusCode::INTERNAL_SERVER_ERROR,
+            message: format!("{error:#}"),
+        }
+    }
+}
+
+impl IntoResponse for ApiError {
+    fn into_response(self) -> Response {
+        (self.status, self.message).into_response()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use axum::body::Body;
+    use axum::http::{Request, StatusCode};
+    use tower::ServiceExt;
+
+    #[tokio::test]
+    async fn archives_endpoint_lists_mounted_archives() {
+        let registry = ServerRegistry {
+            archives: vec![MountedArchive {
+                id: "personal".to_string(),
+                label: "Personal".to_string(),
+                archive_path: std::path::PathBuf::from("/tmp/personal/.archivr"),
+            }],
+        };
+        let response = app(registry)
+            .oneshot(
+                Request::builder()
+                    .uri("/api/archives")
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(response.status(), StatusCode::OK);
+    }
+
+    #[tokio::test]
+    async fn missing_archive_returns_404() {
+        let response = app(ServerRegistry::default())
+            .oneshot(
+                Request::builder()
+                    .uri("/api/archives/missing/entries")
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(response.status(), StatusCode::NOT_FOUND);
+    }
+}