feat: persist execution logs + dashboard detail view + integration tests

Three threads landing together because they share a public surface
(the new execution_log shape) and verifying any one in isolation
would mean re-doing the work later.

== (A) execution log persistence ==

  * shared::ExecutionLog + ExecutionStatus carry the audit-trail
    shape that flows from the orchestrator through the sink and
    back out via the manager's logs endpoint.

  * shared::ExecutionLogSink trait — abstraction the orchestrator
    writes through. In single-process MVP mode the manager's
    Postgres-backed impl is plugged in directly; in cluster mode
    (v1.3+) the orchestrator's impl will post over HTTP to the
    manager. Trait lives in `shared` so neither *-core crate has
    to know about the other.

  * manager-core::PostgresExecutionLogSink writes to the
    execution_logs table (already in the initial migration);
    PostgresExecutionLogRepository reads them back, paginated.
    AdminState now carries both a script repo and a log repo, so
    `admin_router` exposes `GET /scripts/{id}/logs?limit=&offset=`
    capped at 200 rows per page to keep the dashboard responsive.

  * orchestrator-core::DataPlaneState gains `log_sink`. The
    execute handler builds an ExecutionLog on every outcome —
    success, error, timeout, budget-exceeded — and awaits the
    sink. Sink failures are logged at warn and DO NOT mask the
    user-facing result, since "we couldn't write the audit row"
    is a separate concern from "the script ran".

  * picloud binary refactored into a lib (`build_app(pool)` is
    the seam) + thin bin shell. Same Postgres pool backs the
    script repo, the log repo, and the sink — no double pool.

== (B) dashboard ==

  * Typed API client extended with `scripts.logs(id, opts)`,
    `scripts.update/remove`, and `execute(id, body, headers)`.
    Plain `fetch` wrapper now surfaces server-side error
    messages via a typed ApiError so the UI can render them.

  * `/` — create-script form now actually creates; on success
    the list reloads. List entries link to detail.

  * `/scripts/[id]` — new detail route: source editor with save
    (calls update, version bumps); Test invoke panel that sends
    arbitrary JSON body + headers to /api/execute and shows the
    response; Recent executions panel reading from /logs with
    expandable per-row request/response/script-log views.
    Delete button with confirm. SPA-routed; Caddy serves
    `build/` with the same index.html fallback.

== (C) integration tests ==

  * crates/picloud/tests/api.rs — 14 sqlx::test cases driving
    `build_app` through an axum_test::TestServer against a fresh
    Postgres DB per test. Covers: health, full script CRUD,
    duplicate-name conflict, invalid-source rejection on both
    create and update, execute echoing the body, status+header
    passthrough, 404 on missing scripts, error-path executions
    landing in the audit log with the right status.

  * Tests are `#[ignore]` by default so plain `cargo test
    --workspace` stays green without infrastructure. Opt-in via:
    `docker compose up -d postgres && \
       DATABASE_URL=postgres://picloud:picloud@127.0.0.1:15432/picloud \
       cargo test -p picloud --test api -- --include-ignored`

Verified live through Caddy on :8000: three logged invocations
land in the logs endpoint with the right structured `data` on
each `log::info`/`log::warn`, error-path executions are still
captured with status=error, dashboard list + SPA detail route
both reachable.

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

crates/picloud/src/lib.rs

@@ -0,0 +1,114 @@
+//! Library half of the picloud all-in-one. `main.rs` is a thin wrapper
+//! that opens the pool, runs migrations, calls `build_app`, and binds
+//! the listener. Tests use the same `build_app` against an
+//! ephemeral test database.
+
+use std::sync::Arc;
+use std::time::Duration;
+
+use axum::{routing::get, Router};
+use picloud_executor_core::{Engine, Limits};
+use picloud_manager_core::{
+    admin_router, AdminState, PostgresExecutionLogRepository, PostgresExecutionLogSink,
+    PostgresScriptRepository, RepoResolver,
+};
+use picloud_orchestrator_core::{data_plane_router, DataPlaneState, LocalExecutorClient};
+use picloud_shared::{ExecutionLogSink, ScriptValidator};
+use sqlx::postgres::PgPoolOptions;
+use sqlx::PgPool;
+use tower_http::trace::TraceLayer;
+
+/// Compose the manager + orchestrator routes on top of a shared
+/// Postgres pool, returning an Axum router ready to be served.
+pub fn build_app(pool: PgPool) -> Router {
+    let engine = Arc::new(Engine::new(Limits::default()));
+
+    let script_repo = Arc::new(PostgresScriptRepository::new(pool.clone()));
+    let log_repo = Arc::new(PostgresExecutionLogRepository::new(pool.clone()));
+    let log_sink: Arc<dyn ExecutionLogSink> = Arc::new(PostgresExecutionLogSink::new(pool));
+
+    let resolver = Arc::new(RepoResolver::new(PostgresScriptRepoHandle(
+        script_repo.clone(),
+    )));
+    let executor = Arc::new(LocalExecutorClient::new(engine.clone()));
+
+    let admin = AdminState {
+        repo: Arc::new(PostgresScriptRepoHandle(script_repo)),
+        logs: log_repo,
+        validator: engine as Arc<dyn ScriptValidator>,
+    };
+    let data_plane = DataPlaneState {
+        executor,
+        resolver,
+        log_sink,
+    };
+
+    Router::new()
+        .route("/healthz", get(healthz))
+        .route("/", get(root))
+        .nest("/api/admin", admin_router(admin))
+        .nest("/api", data_plane_router(data_plane))
+        .layer(TraceLayer::new_for_http())
+}
+
+/// Open a Postgres pool with the binary's standard timeout settings.
+/// Exposed so tests reach for the same configuration when needed.
+pub async fn init_db(url: &str) -> anyhow::Result<PgPool> {
+    let pool = PgPoolOptions::new()
+        .max_connections(10)
+        .acquire_timeout(Duration::from_secs(5))
+        .connect(url)
+        .await?;
+    Ok(pool)
+}
+
+async fn healthz() -> &'static str {
+    "ok"
+}
+
+async fn root() -> &'static str {
+    "picloud — see /api/admin/* (manager) and /api/execute/* (orchestrator)"
+}
+
+// ----------------------------------------------------------------------------
+// Bridge: a single `PostgresScriptRepository` Arc is shared between the
+// admin router (writes) and the resolver (reads). The resolver wants
+// owned `impl ScriptRepository`, so we wrap the Arc in a delegating
+// handle here rather than instantiating two repos against the same pool.
+// ----------------------------------------------------------------------------
+
+struct PostgresScriptRepoHandle(Arc<PostgresScriptRepository>);
+
+#[async_trait::async_trait]
+impl picloud_manager_core::ScriptRepository for PostgresScriptRepoHandle {
+    async fn get(
+        &self,
+        id: picloud_shared::ScriptId,
+    ) -> Result<Option<picloud_shared::Script>, picloud_manager_core::ScriptRepositoryError> {
+        self.0.get(id).await
+    }
+    async fn list(
+        &self,
+    ) -> Result<Vec<picloud_shared::Script>, picloud_manager_core::ScriptRepositoryError> {
+        self.0.list().await
+    }
+    async fn create(
+        &self,
+        input: picloud_manager_core::NewScript,
+    ) -> Result<picloud_shared::Script, picloud_manager_core::ScriptRepositoryError> {
+        self.0.create(input).await
+    }
+    async fn update(
+        &self,
+        id: picloud_shared::ScriptId,
+        patch: picloud_manager_core::ScriptPatch,
+    ) -> Result<picloud_shared::Script, picloud_manager_core::ScriptRepositoryError> {
+        self.0.update(id, patch).await
+    }
+    async fn delete(
+        &self,
+        id: picloud_shared::ScriptId,
+    ) -> Result<(), picloud_manager_core::ScriptRepositoryError> {
+        self.0.delete(id).await
+    }
+}

crates/picloud/src/main.rs

@@ -1,32 +1,11 @@
-//! PiCloud all-in-one binary — manager + orchestrator + executor in
-//! one process. The only binary built for MVP.
-//!
-//! On startup it opens the Postgres pool, runs migrations, builds the
-//! Rhai engine, then nests both core routers behind a single Axum
-//! listener:
-//!
-//!   /api/admin/*        → manager-core (script CRUD)
-//!   /api/execute/{id}   → orchestrator-core (data plane)
-//!   /healthz            → liveness probe
-//!
-//! Cluster-mode (v1.3+) keeps this layout — splits each nested router
-//! into its own binary, swaps `LocalExecutorClient` for the remote one,
-//! and points Caddy at the new upstreams.
+//! PiCloud all-in-one binary — see `lib.rs` for the actual app
+//! composition; this file is only the runtime shell (env config,
+//! logger, migrations, listener).
 
 use std::net::SocketAddr;
-use std::sync::Arc;
-use std::time::Duration;
 
-use axum::{routing::get, Router};
-use picloud_executor_core::{Engine, Limits};
-use picloud_manager_core::{
-    admin_router, migrations, AdminState, PostgresScriptRepository, RepoResolver,
-};
-use picloud_orchestrator_core::{data_plane_router, DataPlaneState, LocalExecutorClient};
-use picloud_shared::ScriptValidator;
-use sqlx::postgres::PgPoolOptions;
-use sqlx::PgPool;
-use tower_http::trace::TraceLayer;
+use picloud::{build_app, init_db};
+use picloud_manager_core::migrations;
 use tracing_subscriber::EnvFilter;
 
 #[tokio::main]
@@ -61,45 +40,6 @@ fn init_tracing() {
         .init();
 }
 
-async fn init_db(url: &str) -> anyhow::Result<PgPool> {
-    let pool = PgPoolOptions::new()
-        .max_connections(10)
-        .acquire_timeout(Duration::from_secs(5))
-        .connect(url)
-        .await?;
-    Ok(pool)
-}
-
-fn build_app(pool: PgPool) -> Router {
-    // Core services. The `Arc`s let the routers and any background
-    // tasks share the same instances cheaply.
-    let engine = Arc::new(Engine::new(Limits::default()));
-    let repo = Arc::new(PostgresScriptRepository::new(pool));
-    let resolver = Arc::new(RepoResolver::new(PostgresScriptRepoHandle(repo.clone())));
-    let executor = Arc::new(LocalExecutorClient::new(engine.clone()));
-
-    let admin = AdminState {
-        repo: Arc::new(PostgresScriptRepoHandle(repo)),
-        validator: engine as Arc<dyn ScriptValidator>,
-    };
-    let data_plane = DataPlaneState { executor, resolver };
-
-    Router::new()
-        .route("/healthz", get(healthz))
-        .route("/", get(root))
-        .nest("/api/admin", admin_router(admin))
-        .nest("/api", data_plane_router(data_plane))
-        .layer(TraceLayer::new_for_http())
-}
-
-async fn healthz() -> &'static str {
-    "ok"
-}
-
-async fn root() -> &'static str {
-    "picloud — see /api/admin/* (manager) and /api/execute/* (orchestrator)"
-}
-
 async fn shutdown_signal() {
     let ctrl_c = async {
         let _ = tokio::signal::ctrl_c().await;
@@ -119,46 +59,3 @@ async fn shutdown_signal() {
         () = terminate => tracing::info!("SIGTERM received, draining"),
     }
 }
-
-// ----------------------------------------------------------------------------
-// Bridge: PostgresScriptRepository is constructed once and shared via
-// Arc; `RepoResolver` wants ownership of an impl of `ScriptRepository`.
-// We pass a thin wrapper that delegates to the Arc'd repo, so a single
-// connection pool backs both the admin router and the resolver.
-// ----------------------------------------------------------------------------
-
-struct PostgresScriptRepoHandle(Arc<PostgresScriptRepository>);
-
-#[async_trait::async_trait]
-impl picloud_manager_core::ScriptRepository for PostgresScriptRepoHandle {
-    async fn get(
-        &self,
-        id: picloud_shared::ScriptId,
-    ) -> Result<Option<picloud_shared::Script>, picloud_manager_core::ScriptRepositoryError> {
-        self.0.get(id).await
-    }
-    async fn list(
-        &self,
-    ) -> Result<Vec<picloud_shared::Script>, picloud_manager_core::ScriptRepositoryError> {
-        self.0.list().await
-    }
-    async fn create(
-        &self,
-        input: picloud_manager_core::NewScript,
-    ) -> Result<picloud_shared::Script, picloud_manager_core::ScriptRepositoryError> {
-        self.0.create(input).await
-    }
-    async fn update(
-        &self,
-        id: picloud_shared::ScriptId,
-        patch: picloud_manager_core::ScriptPatch,
-    ) -> Result<picloud_shared::Script, picloud_manager_core::ScriptRepositoryError> {
-        self.0.update(id, patch).await
-    }
-    async fn delete(
-        &self,
-        id: picloud_shared::ScriptId,
-    ) -> Result<(), picloud_manager_core::ScriptRepositoryError> {
-        self.0.delete(id).await
-    }
-}