Factory recreate mode; chunked uploads with progress everywhere

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
Richard ZinkandClaude Sonnet 5.5 committed 2026-11-18 13:49:16 +01:00
1 parent 771c6f5245
commit b309778be8
17 files changed
+477 -47

No files matched your search

+49 -3
View File
@@ -150,6 +150,8 @@ pub fn router(app: AppState) -> Router {
.route("/backups", get(list_backups).post(run_backup))
.route("/backups/{name}", get(download_backup))
.route("/backups/{name}/restore", post(restore_stored_backup))
.route("/backups/upload", put(upload_backup_chunk))
.route("/backups/restore-uploaded", post(restore_chunked_backup))
.route("/backups/restore", post(restore_uploaded_backup).layer(axum::extract::DefaultBodyLimit::max(4 * 1024 * 1024 * 1024)))
.route("/health", get(health))
.route("/tools", get(crate::reverse::status))
@@ -1964,6 +1966,43 @@ async fn restore_uploaded_backup(Extension(user): Extension<User>, State(app): S
restore_and_restart(&app, &user, body.to_vec(), &format!("upload ({} bytes)", body.len())).await
}
#[derive(Deserialize)]
struct ChunkQuery {
offset: u64,
}
fn restore_upload_path(app: &App) -> std::path::PathBuf {
app.config().data_dir().join("restore-upload.tmp")
}
/// One chunk of a backup to restore (offset 0 starts anew); `restore-uploaded` applies the whole file.
async fn upload_backup_chunk(Extension(user): Extension<User>, State(app): State<AppState>, Query(q): Query<ChunkQuery>, body: axum::body::Bytes) -> ApiResult {
require_admin(&user)?;
use tokio::io::AsyncWriteExt;
let p = restore_upload_path(&app);
if q.offset == 0 {
tokio::fs::write(&p, &body).await?;
} else {
let current = tokio::fs::metadata(&p).await.map(|m| m.len()).unwrap_or(0);
if current != q.offset {
return Err(ApiError(StatusCode::CONFLICT, format!("chunk offset {} does not match the uploaded size {current}", q.offset)));
}
let mut f = tokio::fs::OpenOptions::new().append(true).open(&p).await?;
f.write_all(&body).await?;
f.flush().await?;
}
Ok(Json(json!({"ok": true, "size": q.offset + body.len() as u64})))
}
async fn restore_chunked_backup(Extension(user): Extension<User>, State(app): State<AppState>) -> ApiResult {
require_admin(&user)?;
let p = restore_upload_path(&app);
let bytes = tokio::fs::read(&p).await.map_err(|_| ApiError(StatusCode::BAD_REQUEST, "no uploaded backup".into()))?;
let _ = tokio::fs::remove_file(&p).await;
let source = format!("upload ({} bytes)", bytes.len());
restore_and_restart(&app, &user, bytes, &source).await
}
async fn download_backup(Extension(user): Extension<User>, State(app): State<AppState>, Path(name): Path<String>) -> Result<Response, ApiError> {
require_admin(&user)?;
if !crate::backup::list(&app).iter().any(|b| b.name == name) {
@@ -2914,13 +2953,20 @@ async fn test_factory_connection(Extension(user): Extension<User>, State(app): S
struct NewDraft {
#[serde(default)]
model: Option<String>,
/// "recreate": analyse existing software first (clean-room).
#[serde(default)]
mode: Option<String>,
#[serde(default)]
source: String,
#[serde(default)]
notes: String,
}
/// Start a chat in which the user writes a spec with a model.
async fn factory_new_draft(Extension(user): Extension<User>, State(app): State<AppState>, Json(b): Json<NewDraft>) -> ApiResult {
let s: crate::factory::FactorySettings = app.store.user_setting(&user.id, "factory")?;
let model = b.model.filter(|m| !m.is_empty()).unwrap_or(s.defaults.spec_model.clone());
let session = crate::factory::start_spec_chat(&app, &user, &model).map_err(|e| ApiError(StatusCode::BAD_REQUEST, format!("{e:#}")))?;
let session = crate::factory::start_spec_chat(&app, &user, &model, (b.mode.as_deref() == Some("recreate")).then_some((b.source.as_str(), b.notes.as_str()))).map_err(|e| ApiError(StatusCode::BAD_REQUEST, format!("{e:#}")))?;
Ok(Json(json!(session)))
}
@@ -2937,7 +2983,7 @@ async fn factory_draft(Extension(user): Extension<User>, State(app): State<AppSt
let s: crate::factory::FactorySettings = app.store.user_setting(&user.id, "factory")?;
let conns: Vec<Value> = s.connections.iter().map(|c| json!({"id": c.id, "name": c.name, "kind": c.kind, "owner": c.owner})).collect();
let setup = std::fs::read_to_string(dir.join("setup.json")).ok().filter(|t| crate::factory::valid_setup(t));
Ok(Json(json!({"spec": spec, "setup": setup, "proposal": crate::factory::proposal(&app, &id), "connections": conns})))
Ok(Json(json!({"spec": spec, "setup": setup, "proposal": crate::factory::proposal(&app, &id), "connections": conns, "recreate": dir.join("recreate.txt").exists()})))
}
#[derive(Deserialize)]
@@ -2957,7 +3003,7 @@ async fn factory_create_project(Extension(user): Extension<User>, State(app): St
let spec = std::fs::read_to_string(dir.join("spec.md")).unwrap_or_default();
let mut s: crate::factory::FactorySettings = app.store.user_setting(&user.id, "factory")?;
let setup = std::fs::read_to_string(dir.join("setup.json")).unwrap_or_default();
let res = crate::factory::create_project(&app, &user, &mut s, &spec, &setup, &b.connection, &b.name, &b.slug, &b.description, &b.owner).await.map_err(|e| ApiError(StatusCode::BAD_GATEWAY, format!("{e:#}")))?;
let res = crate::factory::create_project(&app, &user, &mut s, &spec, &setup, &b.connection, &b.name, &b.slug, &b.description, &b.owner, !dir.join("recreate.txt").exists()).await.map_err(|e| ApiError(StatusCode::BAD_GATEWAY, format!("{e:#}")))?;
app.store.set_user_setting(&user.id, "factory", &s)?;
app.audit(Some(&user), "factory.project.create", res["repo"].as_str().unwrap_or(""), &crate::auth::client_ip(&headers));
Ok(Json(res))