Skip to content

armgit / kokon

Public Imported from GitHub
0

Edit photos by describing the change, on your own GPU. A free, open-source alternative to Nano Banana and ChatGPT image editing: photos stay on your computer, no daily limit. One installer for Windows, Mac and Linux sets up the best open model (Qwen-Image 2.1). MCP server for AI agents.

Projects shared by every device: kokon-service keeps the list (projects.json)

Gabriele Lozupone9f3c159e0fc8
diff --git a/crates/qls-core/src/engine.rs b/crates/qls-core/src/engine.rs
index cb5f545..740e4e6 100644
--- a/crates/qls-core/src/engine.rs
+++ b/crates/qls-core/src/engine.rs
@@ -110,6 +110,8 @@ pub enum Event {
Job { job: Box<JobView> },
Server { state: ServerState, owned: bool, error: Option<AppError> },
Gallery { id: String, change: &'static str },
+ /// A project changed (`rev`) or was removed: the other devices reload it.
+ Projects { id: String, rev: u64, deleted: bool },
}
pub struct Engine {
@@ -119,6 +121,8 @@ pub struct Engine {
/// Private mode: records in memory, files under `private_dir`; wiped by `clear_private`,
/// at start and at exit. Never listed in the gallery.
pub private_store: Arc<Store>,
+ /// The project list every device shares (`projects.rs`).
+ pub projects: crate::projects::ProjectStore,
/// Measured speed of this machine, for time estimates.
speed: crate::speed::SpeedBook,
data_dir: PathBuf,
@@ -239,6 +243,7 @@ impl Engine {
server: ServerManager::new(data_dir.to_path_buf()),
store,
private_store,
+ projects: if cfg!(test) { crate::projects::ProjectStore::in_memory() } else { crate::projects::ProjectStore::open(data_dir) },
speed: if cfg!(test) { crate::speed::SpeedBook::in_memory() } else { crate::speed::SpeedBook::open(data_dir) },
data_dir: data_dir.to_path_buf(),
private_dir,
@@ -443,6 +448,26 @@ impl Engine {
if self.store.get_input(id).is_err() && self.private_store.get_input(id).is_ok() { &self.private_store } else { &self.store }
}
+ /// The records of project `id`'s versions (see [`crate::projects::Records`]), from either
+ /// store; `None` for an unknown project.
+ pub fn project_records(&self, id: &str) -> Option<crate::projects::Records> {
+ let p = self.projects.get(id)?;
+ let mut out = crate::projects::Records::default();
+ for i in &p.items {
+ if let Some(g) = &i.gen_id
+ && let Ok(r) = self.gen_store(g).get_generation(g)
+ {
+ out.generations.insert(g.clone(), r);
+ }
+ if let Some(r) = &i.input_id
+ && let Ok(rec) = self.input_store(r).get_input(r)
+ {
+ out.inputs.insert(r.clone(), rec);
+ }
+ }
+ Some(out)
+ }
+
/// Where a generation's image file may be deleted from: the output folder, or the
/// private folder for private results.
pub fn output_root(&self, id: &str) -> PathBuf {
@@ -550,6 +575,12 @@ impl Engine {
v
}
+ pub fn emit_projects(&self, changes: Vec<crate::projects::Change>) {
+ for c in changes {
+ let _ = self.events.send(Event::Projects { id: c.id, rev: c.rev, deleted: c.deleted });
+ }
+ }
+
fn emit_job(&self, id: &str) {
if let Some(v) = self.job(id) {
let _ = self.events.send(Event::Job { job: Box::new(v) });
@@ -1240,12 +1271,20 @@ impl Engine {
}
records.push(rec);
}
+ let gen_ids: Vec<String> = records.iter().map(|r| r.id.clone()).collect();
self.update(id, |j| {
j.view.status = JobStatus::Done;
j.view.results = records;
j.view.finished_at = Some(now_rfc3339());
j.view.stage = None;
});
+ // The project waiting for it gets its images even with no app open to add them.
+ if !request.private {
+ match self.projects.job_done(id, &gen_ids, now_ms()) {
+ Ok(changes) => self.emit_projects(changes),
+ Err(e) => tracing::warn!("job {id}: project list not updated: {e}"),
+ }
+ }
Ok(())
}
@@ -1700,6 +1739,11 @@ pub fn encode_output(img: &image::RgbaImage, format: OutputFormat, rec: &Generat
}
}
+/// Milliseconds since 1970, as the UI's `Date.now()`.
+pub fn now_ms() -> f64 {
+ std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_millis() as f64).unwrap_or(0.0)
+}
+
pub fn write_atomic(path: &Path, bytes: &[u8]) -> AppResult<()> {
let tmp = path.with_extension(format!("{}.part", path.extension().map(|e| e.to_string_lossy().into_owned()).unwrap_or_default()));
std::fs::write(&tmp, bytes).map_err(|e| AppError::io("write the image", &tmp, e))?;
@@ -2230,6 +2274,48 @@ mod tests {
assert!(reused_seed_note(4001, 5, 2).contains("made a reference image"));
}
+ #[test]
+ fn project_records_come_in_one_answer() {
+ let dir = tempfile::tempdir().unwrap();
+ // SAFETY: test-only env override, single-threaded setup.
+ unsafe { std::env::set_var("QLS_CONFIG_DIR", dir.path().join("cfg")) };
+ let mut cfg = AppConfig::default();
+ cfg.sdcpp_dir = dir.path().join("sdcpp");
+ cfg.normalize();
+ let e = Engine::new(cfg, dir.path()).unwrap();
+ let png = imaging::encode_png(&image::RgbaImage::from_pixel(8, 8, image::Rgba([1, 2, 3, 255])), &[], None, true).unwrap();
+ let input = e.store.put_input(&png, Some("a.png"), None).unwrap();
+ e.store.insert_generation(&test_record("g1", 1, "g1.png")).unwrap();
+ // Made in private mode: in the other store.
+ e.private_store.insert_generation(&test_record("p1", 2, "p1.png")).unwrap();
+ let item = |key: &str, kind: &str, gen_id: Option<&str>, input_id: Option<&str>| crate::projects::Item {
+ key: key.into(),
+ kind: kind.into(),
+ gen_id: gen_id.map(Into::into),
+ input_id: input_id.map(Into::into),
+ job_id: None,
+ extra: Default::default(),
+ };
+ let items = vec![
+ item("i", "input", None, Some(&input.id)),
+ item("a", "gen", Some("g1"), None),
+ item("b", "gen", Some("p1"), None),
+ item("gone", "gen", Some("deleted"), None),
+ item("j", "job", None, None),
+ ];
+ let meta = crate::projects::Meta { id: "p".into(), title: "t".into(), named: None, updated_at: 1.0, cover: None, count: 0 };
+ let project = crate::projects::Project { meta, items, selected: None, loras: None, rev: 0, extra: Default::default() };
+ e.projects.put("p", project, &Default::default()).unwrap();
+ let r = e.project_records("p").unwrap();
+ let mut gens: Vec<_> = r.generations.keys().cloned().collect();
+ gens.sort();
+ assert_eq!(gens, ["g1", "p1"], "a deleted version is left out");
+ assert_eq!(r.generations["p1"].seed, 2);
+ assert_eq!(r.inputs.len(), 1);
+ assert_eq!(r.inputs[&input.id].original_name.as_deref(), Some("a.png"));
+ assert!(e.project_records("nope").is_none());
+ }
+
#[test]
fn reference_seeds_come_from_metadata_and_gallery() {
let dir = tempfile::tempdir().unwrap();
diff --git a/crates/qls-core/src/lib.rs b/crates/qls-core/src/lib.rs
index c87d53f..ed5f22f 100644
--- a/crates/qls-core/src/lib.rs
+++ b/crates/qls-core/src/lib.rs
@@ -18,6 +18,7 @@ pub mod paths;
pub mod pipeline;
pub mod planner;
pub mod process;
+pub mod projects;
pub mod remote;
pub mod sdcpp;
pub mod speed;
diff --git a/crates/qls-core/src/projects.rs b/crates/qls-core/src/projects.rs
new file mode 100644
index 0000000..347839b
--- /dev/null
+++ b/crates/qls-core/src/projects.rs
@@ -0,0 +1,590 @@
+//! The project list, shared by every device that uses this Kokon (the desktop app, a phone's
+//! browser). Before 0.11 each app kept it in its own browser storage; each one now sends that
+//! copy once (`import`) and from then on reads and saves here.
+//!
+//! A project is the UI's: a title and its versions in order (`items`), each one a gallery image,
+//! an imported image or a job still running. Two devices can change the same project at once
+//! (an edit made on the phone while the computer has it open), so a save is merged, not
+//! overwritten: the saving device sends the versions it knew (`known`), and versions it did not
+//! know (added elsewhere since) are kept, while versions it knew and left out were removed by it.
+//! Removed projects leave a tombstone, so a device that had not heard yet cannot bring them back.
+//! Stored in `<data>/projects.json`.
+
+use std::collections::{HashMap, HashSet};
+use std::path::{Path, PathBuf};
+use std::sync::Mutex;
+
+use serde::{Deserialize, Serialize};
+use serde_json::{Map, Value};
+
+use crate::error::{AppError, AppResult, ErrorCode};
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct Item {
+ pub key: String,
+ /// "gen", "input" or "job".
+ pub kind: String,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub gen_id: Option<String>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub input_id: Option<String>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub job_id: Option<String>,
+ /// Fields of newer apps, kept as they are (the request of a running job among them).
+ #[serde(flatten)]
+ pub extra: Map<String, Value>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct Meta {
+ pub id: String,
+ pub title: String,
+ /// The title was typed by the user (otherwise it follows the first prompt).
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub named: Option<bool>,
+ /// Milliseconds since 1970: the list is sorted by it.
+ pub updated_at: f64,
+ #[serde(default)]
+ pub cover: Option<String>,
+ #[serde(default)]
+ pub count: u32,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct Project {
+ pub meta: Meta,
+ #[serde(default)]
+ pub items: Vec<Item>,
+ #[serde(default)]
+ pub selected: Option<String>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub loras: Option<Vec<String>>,
+ /// Bumped by every change here; a device ignores news of a revision it already has.
+ #[serde(default)]
+ pub rev: u64,
+ #[serde(flatten)]
+ pub extra: Map<String, Value>,
+}
+
+#[derive(Default, Serialize, Deserialize)]
+struct File {
+ #[serde(default)]
+ projects: HashMap<String, Project>,
+ /// Removed project id → when (ms).
+ #[serde(default)]
+ deleted: HashMap<String, f64>,
+}
+
+/// The gallery and input records of a project's versions, sent in one answer to a browser
+/// opening it (one request per version is slow on a phone). A version whose record is gone
+/// (deleted from the gallery) is left out.
+#[derive(Debug, Default, Serialize)]
+pub struct Records {
+ pub generations: HashMap<String, crate::store::GenerationRecord>,
+ pub inputs: HashMap<String, crate::store::InputRecord>,
+}
+
+/// What a change did, for the event the other devices hear.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Change {
+ pub id: String,
+ pub rev: u64,
+ pub deleted: bool,
+}
+
+pub struct ProjectStore {
+ path: Option<PathBuf>,
+ data: Mutex<File>,
+}
+
+fn source(i: &Item) -> Option<String> {
+ i.gen_id
+ .as_ref()
+ .map(|g| format!("gen:{g}"))
+ .or_else(|| i.input_id.as_ref().map(|r| format!("input:{r}")))
+}
+
+/// The cover (the latest image) and the number of versions, as the UI computes them.
+fn refresh_meta(p: &mut Project) {
+ p.meta.cover = p.items.iter().rev().find_map(source);
+ p.meta.count = p.items.iter().filter(|i| i.kind != "job").count() as u32;
+}
+
+/// Merges a device's save into the stored copy (see the module comment). Pure, for the tests.
+pub fn merge(stored: Option<&Project>, incoming: Project, known: &HashSet<String>) -> Project {
+ let Some(stored) = stored else {
+ let mut p = incoming;
+ p.rev = 1;
+ refresh_meta(&mut p);
+ return p;
+ };
+ let mut items = incoming.items.clone();
+ // Versions added elsewhere since this device last heard: each goes back after the version
+ // it followed there (or at the end).
+ let mut anchor: Option<String> = None;
+ for it in &stored.items {
+ if items.iter().any(|x| x.key == it.key) {
+ anchor = Some(it.key.clone());
+ continue;
+ }
+ if known.contains(&it.key) {
+ continue;
+ }
+ let at = anchor
+ .as_ref()
+ .and_then(|a| items.iter().position(|x| &x.key == a))
+ .map(|k| k + 1)
+ .unwrap_or(items.len());
+ items.insert(at, it.clone());
+ anchor = Some(it.key.clone());
+ }
+ // A running job whose images arrived (here or on another device) is no longer pending.
+ let finished: HashSet<String> = items
+ .iter()
+ .filter(|i| i.kind != "job")
+ .filter_map(|i| i.job_id.clone())
+ .collect();
+ items.retain(|i| i.kind != "job" || !i.job_id.as_ref().is_some_and(|j| finished.contains(j)));
+
+ let mut meta = incoming.meta.clone();
+ // A name typed on another device is kept over a title this device made up from a prompt.
+ if stored.meta.named == Some(true) && incoming.meta.named != Some(true) {
+ meta.title = stored.meta.title.clone();
+ meta.named = Some(true);
+ }
+ meta.updated_at = meta.updated_at.max(stored.meta.updated_at);
+ let has = |k: &Option<String>| {
+ k.as_ref()
+ .is_some_and(|k| items.iter().any(|i| &i.key == k))
+ };
+ let selected = if has(&incoming.selected) {
+ incoming.selected.clone()
+ } else if has(&stored.selected) {
+ stored.selected.clone()
+ } else {
+ items.last().map(|i| i.key.clone())
+ };
+ let mut p = Project {
+ meta,
+ items,
+ selected,
+ loras: incoming.loras.clone(),
+ rev: stored.rev + 1,
+ extra: incoming.extra,
+ };
+ refresh_meta(&mut p);
+ p
+}
+
+impl ProjectStore {
+ /// Loads `<data_dir>/projects.json` (missing: an empty list).
+ pub fn open(data_dir: &Path) -> Self {
+ let path = data_dir.join("projects.json");
+ let data = match std::fs::read_to_string(&path) {
+ Ok(t) => serde_json::from_str(&t).unwrap_or_else(|e| {
+ // Unreadable: kept aside instead of being overwritten by the next save.
+ tracing::warn!("projects.json is unreadable ({e}); kept as projects.json.bad");
+ let _ = std::fs::rename(&path, path.with_extension("json.bad"));
+ File::default()
+ }),
+ Err(_) => File::default(),
+ };
+ Self {
+ path: Some(path),
+ data: Mutex::new(data),
+ }
+ }
+
+ /// Not persisted (tests).
+ pub fn in_memory() -> Self {
+ Self {
+ path: None,
+ data: Mutex::new(File::default()),
+ }
+ }
+
+ fn save(&self, f: &File) -> AppResult<()> {
+ let Some(path) = &self.path else {
+ return Ok(());
+ };
+ let text = serde_json::to_vec(f).map_err(AppError::internal)?;
+ let tmp = path.with_extension("json.part");
+ std::fs::write(&tmp, text).map_err(|e| AppError::io("save the project list", &tmp, e))?;
+ std::fs::rename(&tmp, path).map_err(|e| AppError::io("save the project list", path, e))
+ }
+
+ /// Every project, most recent first.
+ pub fn list(&self) -> Vec<Project> {
+ let mut v: Vec<Project> = self
+ .data
+ .lock()
+ .unwrap()
+ .projects
+ .values()
+ .cloned()
+ .collect();
+ v.sort_by(|a, b| b.meta.updated_at.total_cmp(&a.meta.updated_at));
+ v
+ }
+
+ pub fn get(&self, id: &str) -> Option<Project> {
+ self.data.lock().unwrap().projects.get(id).cloned()
+ }
+
+ /// Saves a device's copy of project `id`, merged with what is stored. A removed project
+ /// stays removed (NotFound).
+ pub fn put(
+ &self,
+ id: &str,
+ mut incoming: Project,
+ known: &HashSet<String>,
+ ) -> AppResult<(Project, Change)> {
+ let mut f = self.data.lock().unwrap();
+ if f.deleted.contains_key(id) {
+ return Err(AppError::new(
+ ErrorCode::NotFound,
+ "This project was removed on another device.",
+ ));
+ }
+ incoming.meta.id = id.to_string();
+ let merged = merge(f.projects.get(id), incoming, known);
+ f.projects.insert(id.to_string(), merged.clone());
+ self.save(&f)?;
+ let change = Change {
+ id: id.to_string(),
+ rev: merged.rev,
+ deleted: false,
+ };
+ Ok((merged, change))
+ }
+
+ pub fn delete(&self, id: &str, now_ms: f64) -> AppResult<Change> {
+ let mut f = self.data.lock().unwrap();
+ f.projects.remove(id);
+ f.deleted.insert(id.to_string(), now_ms);
+ self.save(&f)?;
+ Ok(Change {
+ id: id.to_string(),
+ rev: 0,
+ deleted: true,
+ })
+ }
+
+ /// A device's list from before 0.11 (its browser storage). Projects not here are added,
+ /// ones here are merged (nothing of either copy is lost), removed ones stay removed.
+ /// Sending the same list again changes nothing.
+ pub fn import(&self, list: Vec<Project>) -> AppResult<Vec<Change>> {
+ let mut f = self.data.lock().unwrap();
+ let mut changes = Vec::new();
+ for p in list {
+ let id = p.meta.id.clone();
+ if id.is_empty() || f.deleted.contains_key(&id) {
+ continue;
+ }
+ let stored = f.projects.get(&id);
+ let merged = merge(stored, p, &HashSet::new());
+ if stored.is_some_and(|s| merged.items == s.items && merged.meta.title == s.meta.title)
+ {
+ continue;
+ }
+ changes.push(Change {
+ id: id.clone(),
+ rev: merged.rev,
+ deleted: false,
+ });
+ f.projects.insert(id, merged);
+ }
+ if !changes.is_empty() {
+ self.save(&f)?;
+ }
+ Ok(changes)
+ }
+
+ /// Job `job_id` finished: in every project waiting for it, its images replace the pending
+ /// version (keys "r-<image id>", the same the apps use, so a device doing it too adds nothing).
+ pub fn job_done(
+ &self,
+ job_id: &str,
+ gen_ids: &[String],
+ now_ms: f64,
+ ) -> AppResult<Vec<Change>> {
+ let mut f = self.data.lock().unwrap();
+ let mut changes = Vec::new();
+ for p in f.projects.values_mut() {
+ let Some(k) = p
+ .items
+ .iter()
+ .position(|i| i.kind == "job" && i.job_id.as_deref() == Some(job_id))
+ else {
+ continue;
+ };
+ let results: Vec<Item> = gen_ids
+ .iter()
+ .map(|g| Item {
+ key: format!("r-{g}"),
+ kind: "gen".into(),
+ gen_id: Some(g.clone()),
+ input_id: None,
+ job_id: Some(job_id.to_string()),
+ extra: Map::new(),
+ })
+ .filter(|r| !p.items.iter().any(|i| i.key == r.key))
+ .collect();
+ let pending = p.items[k].key.clone();
+ let first = results.first().map(|r| r.key.clone());
+ p.items.splice(k..k + 1, results);
+ if p.selected.as_deref() == Some(pending.as_str()) {
+ p.selected = first.or_else(|| p.items.last().map(|i| i.key.clone()));
+ }
+ p.meta.updated_at = p.meta.updated_at.max(now_ms);
+ p.rev += 1;
+ refresh_meta(p);
+ changes.push(Change {
+ id: p.meta.id.clone(),
+ rev: p.rev,
+ deleted: false,
+ });
+ }
+ if !changes.is_empty() {
+ self.save(&f)?;
+ }
+ Ok(changes)
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn img(key: &str) -> Item {
+ Item {
+ key: key.into(),
+ kind: "gen".into(),
+ gen_id: Some(format!("g{key}")),
+ input_id: None,
+ job_id: None,
+ extra: Map::new(),
+ }
+ }
+
+ fn job(key: &str, job: &str) -> Item {
+ Item {
+ key: key.into(),
+ kind: "job".into(),
+ gen_id: None,
+ input_id: None,
+ job_id: Some(job.into()),
+ extra: Map::new(),
+ }
+ }
+
+ fn project(id: &str, items: Vec<Item>) -> Project {
+ Project {
+ meta: Meta {
+ id: id.into(),
+ title: "A prompt".into(),
+ named: None,
+ updated_at: 1.0,
+ cover: None,
+ count: 0,
+ },
+ selected: items.last().map(|i| i.key.clone()),
+ items,
+ loras: None,
+ rev: 0,
+ extra: Map::new(),
+ }
+ }
+
+ fn keys(p: &Project) -> Vec<&str> {
+ p.items.iter().map(|i| i.key.as_str()).collect()
+ }
+
+ fn known(k: &[&str]) -> HashSet<String> {
+ k.iter().map(|s| s.to_string()).collect()
+ }
+
+ #[test]
+ fn a_new_project_is_stored_with_its_cover_and_count() {
+ let s = ProjectStore::in_memory();
+ let (p, c) = s
+ .put(
+ "p",
+ project("p", vec![img("a"), job("b", "j1")]),
+ &known(&[]),
+ )
+ .unwrap();
+ assert_eq!(
+ c,
+ Change {
+ id: "p".into(),
+ rev: 1,
+ deleted: false
+ }
+ );
+ assert_eq!(p.meta.cover.as_deref(), Some("gen:ga"));
+ assert_eq!(p.meta.count, 1);
+ }
+
+ #[test]
+ fn versions_added_on_two_devices_are_both_kept() {
+ let s = ProjectStore::in_memory();
+ s.put("p", project("p", vec![img("a")]), &known(&[]))
+ .unwrap();
+ // The phone adds b, the computer (which only knew a) adds c.
+ s.put("p", project("p", vec![img("a"), img("b")]), &known(&["a"]))
+ .unwrap();
+ let (p, _) = s
+ .put("p", project("p", vec![img("a"), img("c")]), &known(&["a"]))
+ .unwrap();
+ assert_eq!(keys(&p), ["a", "b", "c"]);
+ assert_eq!(p.rev, 3);
+ }
+
+ #[test]
+ fn a_version_removed_by_a_device_that_knew_it_stays_removed() {
+ let s = ProjectStore::in_memory();
+ s.put("p", project("p", vec![img("a"), img("b")]), &known(&[]))
+ .unwrap();
+ let (p, _) = s
+ .put("p", project("p", vec![img("a")]), &known(&["a", "b"]))
+ .unwrap();
+ assert_eq!(keys(&p), ["a"]);
+ }
+
+ #[test]
+ fn a_version_from_elsewhere_goes_back_after_the_one_it_followed() {
+ let stored = project("p", vec![img("a"), img("x"), img("b")]);
+ let p = merge(
+ Some(&stored),
+ project("p", vec![img("a"), img("b"), img("c")]),
+ &known(&["a", "b"]),
+ );
+ assert_eq!(keys(&p), ["a", "x", "b", "c"]);
+ }
+
+ #[test]
+ fn a_finished_job_replaces_its_pending_version_once() {
+ let s = ProjectStore::in_memory();
+ s.put(
+ "p",
+ project("p", vec![img("a"), job("k", "j1")]),
+ &known(&[]),
+ )
+ .unwrap();
+ let ch = s.job_done("j1", &["g1".into(), "g2".into()], 5.0).unwrap();
+ assert_eq!(ch.len(), 1);
+ let p = s.get("p").unwrap();
+ assert_eq!(keys(&p), ["a", "r-g1", "r-g2"]);
+ assert_eq!(p.selected.as_deref(), Some("r-g1"));
+ assert_eq!(p.meta.count, 3);
+ // The app that made it does the same with the same keys: no copies, no pending left.
+ let (p, _) = s
+ .put(
+ "p",
+ project(
+ "p",
+ vec![
+ img("a"),
+ job("k", "j1"),
+ Item {
+ key: "r-g1".into(),
+ job_id: Some("j1".into()),
+ ..img("r-g1")
+ },
+ ],
+ ),
+ &known(&["a", "k"]),
+ )
+ .unwrap();
+ assert_eq!(keys(&p), ["a", "r-g1", "r-g2"]);
+ assert!(s.job_done("j1", &["g1".into()], 6.0).unwrap().is_empty());
+ }
+
+ #[test]
+ fn a_name_typed_elsewhere_beats_a_title_from_a_prompt() {
+ let mut stored = project("p", vec![img("a")]);
+ stored.meta.title = "Holiday".into();
+ stored.meta.named = Some(true);
+ let p = merge(Some(&stored), project("p", vec![img("a")]), &known(&["a"]));
+ assert_eq!(p.meta.title, "Holiday");
+ let mut renamed = project("p", vec![img("a")]);
+ renamed.meta.title = "Trip".into();
+ renamed.meta.named = Some(true);
+ assert_eq!(
+ merge(Some(&stored), renamed, &known(&["a"])).meta.title,
+ "Trip"
+ );
+ }
+
+ #[test]
+ fn removed_projects_stay_removed() {
+ let s = ProjectStore::in_memory();
+ s.put("p", project("p", vec![img("a")]), &known(&[]))
+ .unwrap();
+ s.delete("p", 2.0).unwrap();
+ assert!(
+ s.put("p", project("p", vec![img("a")]), &known(&[]))
+ .is_err()
+ );
+ assert!(
+ s.import(vec![project("p", vec![img("a")])])
+ .unwrap()
+ .is_empty()
+ );
+ assert!(s.list().is_empty());
+ }
+
+ #[test]
+ fn importing_merges_lists_and_twice_changes_nothing() {
+ let s = ProjectStore::in_memory();
+ s.put("p", project("p", vec![img("a")]), &known(&[]))
+ .unwrap();
+ let phone = vec![
+ project("p", vec![img("a"), img("b")]),
+ project("q", vec![img("c")]),
+ ];
+ assert_eq!(s.import(phone.clone()).unwrap().len(), 2);
+ assert_eq!(keys(&s.get("p").unwrap()), ["a", "b"]);
+ assert!(s.import(phone).unwrap().is_empty());
+ assert_eq!(s.list().len(), 2);
+ }
+
+ #[test]
+ fn the_list_survives_a_restart_and_keeps_unknown_fields() {
+ let dir = tempfile::tempdir().unwrap();
+ let s = ProjectStore::open(dir.path());
+ let mut p = project("p", vec![img("a")]);
+ p.items[0].extra.insert("future".into(), Value::from(1));
+ s.put("p", p, &known(&[])).unwrap();
+ let again = ProjectStore::open(dir.path());
+ assert_eq!(
+ again.get("p").unwrap().items[0].extra.get("future"),
+ Some(&Value::from(1))
+ );
+ }
+
+ #[test]
+ fn the_stored_format_reads_what_the_app_saved_before() {
+ // A project as 0.10's UI kept it in browser storage.
+ let v: Project = serde_json::from_str(
+ r#"{"meta":{"id":"p","title":"Cat","updatedAt":1700000000000,"cover":"gen:g1","count":1},
+ "items":[{"key":"k1","kind":"gen","genId":"g1","jobId":"j"},{"key":"k2","kind":"job","jobId":"j2","request":{"prompt":"x"}}],
+ "selected":"k1","loras":["l"]}"#,
+ )
+ .unwrap();
+ assert_eq!(
+ v.items[1]
+ .extra
+ .get("request")
+ .and_then(|r| r.get("prompt")),
+ Some(&Value::from("x"))
+ );
+ let back = serde_json::to_value(&v).unwrap();
+ assert_eq!(back["items"][0]["genId"], "g1");
+ assert_eq!(back["meta"]["updatedAt"], 1700000000000.0);
+ }
+}
diff --git a/crates/qls-core/src/remote.rs b/crates/qls-core/src/remote.rs
index 9877fc9..f79bae6 100644
--- a/crates/qls-core/src/remote.rs
+++ b/crates/qls-core/src/remote.rs
@@ -262,19 +262,20 @@ impl Sessions {
pub fn browser_allowed(method: &str, path: &str) -> bool {
let seg: Vec<&str> = path.trim_matches('/').split('/').collect();
match (method, seg.as_slice()) {
- ("GET", ["status" | "setup" | "models" | "upscalers" | "config" | "diagnostics" | "logs" | "jobs" | "events" | "gallery" | "loras" | "luts"]) => true,
+ ("GET", ["status" | "setup" | "models" | "upscalers" | "config" | "diagnostics" | "logs" | "jobs" | "events" | "gallery" | "loras" | "luts" | "projects"]) => true,
("GET", ["setup", "hardware" | "install" | "legacy-upscalers"]) => true,
("GET", ["enhancer", "defaults"]) => true,
("GET", ["jobs", _] | ["jobs", _, "wait"]) => true,
("GET", ["inputs", _] | ["inputs", _, "image" | "thumb"]) => true,
("GET", ["gallery", _] | ["gallery", _, "image" | "thumb" | "original"]) => true,
("GET", ["luts", _, "preview"]) => true,
+ ("GET" | "PUT" | "DELETE", ["projects", _]) => true,
("PUT", ["config"]) => true,
("POST", ["setup", "install" | "gpu"] | ["setup", "install", "cancel"]) => true,
("POST", ["models", "use" | "vae"]) => true,
("POST", ["upscalers", _, "download"]) => true,
("POST", ["backend", "start" | "stop" | "restart"]) => true,
- ("POST", ["plan" | "jobs" | "inputs" | "examples"]) => true,
+ ("POST", ["plan" | "jobs" | "inputs" | "examples"] | ["projects", "import"]) => true,
("POST", ["jobs", _, "cancel"]) => true,
("POST", ["private", "clear"]) => true,
("POST", ["luts", _, "apply"]) => true,
@@ -454,6 +455,9 @@ mod tests {
("PUT", "/config"),
("POST", "/session/heartbeat"),
("DELETE", "/gallery/abc"),
+ ("GET", "/projects"),
+ ("PUT", "/projects/abc"),
+ ("POST", "/projects/import"),
] {
assert!(browser_allowed(m, p), "{m} {p}");
}
diff --git a/crates/qls-service/src/api.rs b/crates/qls-service/src/api.rs
index 1a7d55e..fea347e 100644
--- a/crates/qls-service/src/api.rs
+++ b/crates/qls-service/src/api.rs
@@ -2,6 +2,7 @@
//! engine adapts between the two). On loopback it takes the token (desktop app, MCP, scripts)
//! or a signed-in browser; on the network listener only a signed-in browser (see `remote`).
+use std::collections::HashSet;
use std::convert::Infallible;
use std::path::{Path, PathBuf};
use std::sync::Arc;
@@ -28,6 +29,7 @@ use qls_core::{
modelfile::{self, FileInfo, Role, Slot},
paths,
planner::{GenerationRequest, InpaintAction, Mode, OutpaintSpec, Quality, UpscaleMethod, UpscaleSpec},
+ projects::Project,
store::{GenerationRecord, ListQuery},
};
use serde::Deserialize;
@@ -115,6 +117,10 @@ pub fn router(state: Arc<AppState>, lan: bool) -> Router {
.route("/luts/{name}/preview", get(luts_preview))
.route("/luts/{name}/apply", post(luts_apply))
.route("/examples", post(install_examples))
+ .route("/projects", get(projects_list))
+ .route("/projects/import", post(projects_import))
+ .route("/projects/{id}", get(projects_get).put(projects_put).delete(projects_delete))
+ .route("/projects/{id}/records", get(projects_records))
.route("/session/heartbeat", post(heartbeat))
.route("/session/release", post(release))
.route("/shutdown", post(shutdown))
@@ -1155,6 +1161,61 @@ async fn gallery_export(State(s): St, AxPath(id): AxPath<String>, Json(b): Json<
}
/// Adds the bundled example projects (first launch, or Settings) and lists them.
+async fn projects_list(State(s): St) -> Json<Value> {
+ Json(json!({ "projects": s.engine.projects.list() }))
+}
+
+async fn projects_get(State(s): St, AxPath(id): AxPath<String>) -> ApiResult<Json<Value>> {
+ let p = s.engine.projects.get(&id).ok_or_else(|| AppError::new(ErrorCode::NotFound, "No such project."))?;
+ Ok(Json(serde_json::to_value(p).unwrap()))
+}
+
+/// Every version's record in one answer (a browser opening the project).
+async fn projects_records(State(s): St, AxPath(id): AxPath<String>) -> ApiResult<Json<Value>> {
+ let engine = s.engine.clone();
+ let r = tokio::task::spawn_blocking(move || engine.project_records(&id)).await.map_err(AppError::internal)?;
+ let r = r.ok_or_else(|| AppError::new(ErrorCode::NotFound, "No such project."))?;
+ Ok(Json(serde_json::to_value(r).unwrap()))
+}
+
+#[derive(Deserialize)]
+struct ProjectPut {
+ project: Project,
+ /// The versions this device knew (see `projects.rs`).
+ #[serde(default)]
+ known: HashSet<String>,
+}
+
+/// Saves a device's copy of a project; answers with the merged one.
+async fn projects_put(State(s): St, AxPath(id): AxPath<String>, Json(b): Json<ProjectPut>) -> ApiResult<Json<Value>> {
+ let engine = s.engine.clone();
+ let (p, change) = tokio::task::spawn_blocking(move || engine.projects.put(&id, b.project, &b.known)).await.map_err(AppError::internal)??;
+ s.engine.emit_projects(vec![change]);
+ Ok(Json(serde_json::to_value(p).unwrap()))
+}
+
+async fn projects_delete(State(s): St, AxPath(id): AxPath<String>) -> ApiResult<Json<Value>> {
+ let engine = s.engine.clone();
+ let key = id.clone();
+ let change = tokio::task::spawn_blocking(move || engine.projects.delete(&key, qls_core::engine::now_ms())).await.map_err(AppError::internal)??;
+ s.engine.emit_projects(vec![change]);
+ Ok(Json(json!({ "deleted": id })))
+}
+
+#[derive(Deserialize)]
+struct ProjectImport {
+ projects: Vec<Project>,
+}
+
+/// A device's project list from before 0.11 (its browser storage), merged in once.
+async fn projects_import(State(s): St, Json(b): Json<ProjectImport>) -> ApiResult<Json<Value>> {
+ let engine = s.engine.clone();
+ let changes = tokio::task::spawn_blocking(move || engine.projects.import(b.projects)).await.map_err(AppError::internal)??;
+ let n = changes.len();
+ s.engine.emit_projects(changes);
+ Ok(Json(json!({ "changed": n, "projects": s.engine.projects.list() })))
+}
+
async fn install_examples(State(s): St) -> ApiResult<Json<Value>> {
let engine = s.engine.clone();
let projects = tokio::task::spawn_blocking(move || engine.install_examples()).await.map_err(AppError::internal)??;
diff --git a/docs/engineering-notes.md b/docs/engineering-notes.md
index c0beb0c..57f808c 100644
--- a/docs/engineering-notes.md
+++ b/docs/engineering-notes.md
@@ -29,6 +29,7 @@ Kokon.exe (Tauri 2 + React) kokon-mcp.exe (MCP, stdio) scripts
| `speed.rs` | Per-machine speed calibration of time estimates |
| `diagnostics.rs` | GPU detection (nvidia-smi, DXGI, sysctl on macOS), readiness checks |
| `store.rs` | SQLite gallery + content-addressed inputs |
+| `projects.rs` | The project list every device shares (`projects.json`): merged saves, tombstones, finished jobs |
| `paths.rs` | Path validation (no UNC/device/ADS/traversal, never overwrite) |
| `catalog.rs`, `installer.rs` | Pinned downloads (URLs, sizes, SHA-256), hardware presets, parallel resumable downloader |
| `config.rs` | Settings and model profiles: the official files (derived from folder + preset) and the user's own files, each recording its model and source |
diff --git a/src/App.tsx b/src/App.tsx
index a556c55..c174781 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -5,7 +5,7 @@ import { api, ApiError, configure, setSignedOutHandler } from "./lib/api";
import { native } from "./lib/native";
import { inBrowser, isNarrow } from "./lib/platform";
import {
- addExampleProjects, closeStarPrompt, dismissToast, getState, initStarPrompt, redoVersion, refreshLoras, refreshStatus, selectItem, setState, startEvents, startTour, submitComposer, toastError, toastInfo, undoVersion, useStore,
+ addExampleProjects, closeStarPrompt, loadProjects, dismissToast, getState, initStarPrompt, redoVersion, refreshLoras, refreshStatus, selectItem, setState, startEvents, startTour, submitComposer, toastError, toastInfo, undoVersion, useStore,
} from "./lib/store";
import { Composer, importPaths, uploadFiles } from "./components/Composer";
import { Login } from "./components/Login";
@@ -146,6 +146,8 @@ export default function App() {
setSignedOutHandler(() => location.reload());
startBrowserHeartbeat();
}
+ // The project list (shared by every device) before anything adds to it.
+ await loadProjects().catch(() => {});
startEvents();
const cfg = await api.config();
const st = await refreshStatus();
diff --git a/src/lib/api.ts b/src/lib/api.ts
index 22a09d2..eb54d15 100644
--- a/src/lib/api.ts
+++ b/src/lib/api.ts
@@ -4,6 +4,7 @@
// every change carries the CSRF header the service asks for.
import { inBrowser } from "./platform";
+import type { ProjectData } from "./store";
import type {
GpuBackend,
AppConfig, AppErrorBody, GenerationRecord, GenerationRequest, HardwareReport, InputRecord, InstallStatus, JobView, LoraItem, LutEntry, ModelFileInfo, ModelScan, ModelSlot, ModelsStatus, Plan,
@@ -164,6 +165,17 @@ export const api = {
applyLut: (name: string, source: string, intensity: number, isPrivate: boolean) =>
call<GenerationRecord>(`/luts/${encodeURIComponent(name)}/apply`, { method: "POST", body: json({ source, intensity, private: isPrivate }) }),
exportGeneration: (id: string, path: string, original = false) => call<{ path: string }>(`/gallery/${id}/export`, { method: "POST", body: json({ path, overwrite: true, original }) }),
+ /** The project list every device shares (crates/qls-core/src/projects.rs). */
+ projects: () => call<{ projects: ProjectData[] }>("/projects"),
+ project: (id: string) => call<ProjectData>(`/projects/${encodeURIComponent(id)}`),
+ /** The records of every version of a project, in one answer; deleted versions are left out. */
+ projectRecords: (id: string) =>
+ call<{ generations: Record<string, GenerationRecord>; inputs: Record<string, InputRecord> }>(`/projects/${encodeURIComponent(id)}/records`),
+ /** `known`: the version keys of the copy last heard from the service; answers with the merged project. */
+ saveProject: (id: string, project: ProjectData, known: string[]) => call<ProjectData>(`/projects/${encodeURIComponent(id)}`, { method: "PUT", body: json({ project, known }) }),
+ deleteProject: (id: string) => call<{ deleted: string }>(`/projects/${encodeURIComponent(id)}`, { method: "DELETE" }),
+ /** This app's list from before 0.11 (browser storage), merged in once. */
+ importProjects: (projects: ProjectData[]) => call<{ changed: number }>("/projects/import", { method: "POST", body: json({ projects }) }),
/** Browser sign-in (see crates/qls-service/src/remote.rs). */
session: () => call<{ signed_in: boolean; password_set: boolean }>("/auth/session"),
login: (password: string) => call<{ signed_in: boolean }>("/auth/login", { method: "POST", body: json({ password }) }),
diff --git a/src/lib/logic.ts b/src/lib/logic.ts
index db6b83b..1d880c0 100644
--- a/src/lib/logic.ts
+++ b/src/lib/logic.ts
@@ -825,6 +825,33 @@ export function compareBase(g: GenerationRecord): CompareBase | null {
return { inputId: r.input_id, rect: { x: 0, y: 0, w: 1, h: 1 } };
}
+/** Long side of the screen-sized copy kokon-service makes of an image for a browser's stage
+ * (`PREVIEW_SIDE` in crates/qls-core/src/store.rs). */
+export const PREVIEW_SIDE = 1280;
+
+/** The stage may show the preview instead of the full image: drawn at `w`×`h` CSS px, the image
+ * needs no more device pixels than the preview has (an iPhone: 390 CSS px × 3 = 1170). */
+export function stageFitsPreview(w: number, h: number, dpr: number): boolean {
+ return w > 0 && h > 0 && Math.max(w, h) * (dpr > 0 ? dpr : 1) <= PREVIEW_SIDE;
+}
+
+/** Versions to drop after loading a project's records in one answer: the ones the service knew
+ * (their key was in its copy, `known`) but sent no record for, i.e. deleted from the gallery.
+ * A version it did not know yet (added here, not saved) is looked up on its own instead. */
+export function goneVersions(
+ items: { key: string; kind: string; genId?: string; inputId?: string }[],
+ records: { generations: Record<string, unknown>; inputs: Record<string, unknown> },
+ known: string[],
+): Set<string> {
+ const knew = new Set(known);
+ const gone = new Set<string>();
+ for (const i of items) {
+ const has = i.kind === "gen" && i.genId ? i.genId in records.generations : i.kind === "input" && i.inputId ? i.inputId in records.inputs : true;
+ if (!has && knew.has(i.key)) gone.add(i.key);
+ }
+ return gone;
+}
+
/** Per-pixel change between two equally sized RGBA buffers: the dimmed result in grey with
* changed pixels in red (stronger = bigger change). Pixels the "before" does not cover
* (alpha 0, e.g. expanded areas) count as changed. Returns the changed share of the image. */
diff --git a/src/lib/store.ts b/src/lib/store.ts
index f80b8c3..e4e63a5 100644
--- a/src/lib/store.ts
+++ b/src/lib/store.ts
@@ -9,7 +9,7 @@ import { inBrowser, isNarrow } from "./platform";
import { useSyncExternalStore } from "react";
import { markFresh } from "../components/Cocoon";
import { api, ApiError, setPrivateInputs, subscribe } from "./api";
-import { activeLoras, buildRequest, composing, emptyComposer, needsPrompt, newKey, pageOutdated, persistentAdvanced, refFromGen, refFromInput, reviewRequest, starPromptDue, timelineLinks, undoTarget, versionLabels, wantsPromptReview, type CompareMode, type Composer, type Ref } from "./logic";
+import { activeLoras, buildRequest, composing, emptyComposer, goneVersions, needsPrompt, newKey, pageOutdated, persistentAdvanced, refFromGen, refFromInput, reviewRequest, starPromptDue, timelineLinks, undoTarget, versionLabels, wantsPromptReview, type CompareMode, type Composer, type Ref } from "./logic";
import type { AppErrorBody, GenerationRecord, GenerationRequest, InputRecord, JobView, LoraItem, ServerState, StatusResponse } from "./types";
export type Overlay = null | "gallery" | "settings" | "inpaint" | "expand" | "welcome" | "whats-new" | "prompt-tips" | "shortcuts";
@@ -134,38 +134,129 @@ interface StoredItem {
request?: GenerationRequest;
}
-interface ProjectData {
+export interface ProjectData {
meta: ProjectMeta;
items: StoredItem[];
selected: string | null;
/** LoRAs switched on in the project (absent = the ones on by default). */
loras?: string[];
+ /** The service's revision of it (see crates/qls-core/src/projects.rs). */
+ rev?: number;
}
-const projects: Record<string, ProjectData> = (() => {
- try {
- const p = JSON.parse(localStorage.getItem(PROJECTS_KEY) || "{}");
- return p && typeof p === "object" ? p : {};
- } catch {
- return {};
- }
-})();
+// The project list lives in kokon-service, shared by every device (0.11). Before, each app
+// kept it in its own browser storage: `loadProjects` sends that copy once, then keeps it
+// as a backup under BACKUP_KEY.
+const projects: Record<string, ProjectData> = {};
+const BACKUP_KEY = "qls.projects.v1.backup";
const genCache = new Map<string, GenerationRecord>();
const inputCache = new Map<string, InputRecord>();
+/** Per project, the version keys of the last copy heard from the service: a save sends them,
+ * so versions added elsewhere since are kept and the ones removed here are removed there. */
+const serverKeys = new Map<string, string[]>();
+/** Projects changed here and not saved yet; `edits` counts changes, so a save's answer is not
+ * applied over a newer change made while it was on its way. */
+const dirty = new Set<string>();
+const edits = new Map<string, number>();
let saveTimer: number | undefined;
-function persistProjects() {
+
+/** What other devices need to hear about (the selection alone is this device's own). */
+const content = (p: ProjectData | undefined) => (p ? JSON.stringify([p.items.map((i) => i.key), p.meta.title, p.meta.named, p.loras]) : "");
+
+function persistProjects(ids: string[]) {
+ for (const id of ids) {
+ dirty.add(id);
+ edits.set(id, (edits.get(id) ?? 0) + 1);
+ }
window.clearTimeout(saveTimer);
- saveTimer = window.setTimeout(() => {
- const keep: Record<string, ProjectData> = {};
- for (const [id, p] of Object.entries(projects)) if (p.items.length || p.meta.named) keep[id] = p;
+ saveTimer = window.setTimeout(flushProjects, 300);
+}
+
+async function flushProjects() {
+ for (const id of [...dirty]) {
+ const p = projects[id];
+ dirty.delete(id);
+ if (!p || !(p.items.length || p.meta.named)) continue;
+ const seq = edits.get(id);
try {
- localStorage.setItem(PROJECTS_KEY, JSON.stringify(keep));
- } catch {
- /* storage unavailable */
+ const merged = await api.saveProject(id, p, serverKeys.get(id) ?? []);
+ if (edits.get(id) === seq) await applyProject(merged);
+ else serverKeys.set(id, merged.items.map((i) => i.key));
+ } catch (e) {
+ if (e instanceof ApiError && e.status === 404) dropProject(id);
+ // Not reachable: saved again once the connection is back (startEvents).
+ else dirty.add(id);
}
- }, 300);
+ }
+}
+
+/** A copy from the service: into the list, and into the open project when its versions differ. */
+async function applyProject(p: ProjectData) {
+ const id = p.meta.id;
+ serverKeys.set(id, p.items.map((i) => i.key));
+ if (dirty.has(id)) return;
+ const old = projects[id];
+ projects[id] = { ...p, selected: old?.selected && p.items.some((i) => i.key === old.selected) ? old.selected : p.selected };
+ if (id !== state.projectId || state.privateMode) {
+ setState({ projects: projectList() });
+ return;
+ }
+ const keys = state.session.map((i) => i.key);
+ if (keys.length === p.items.length && keys.every((k, i) => k === p.items[i].key)) {
+ setState({ projects: projectList() });
+ return;
+ }
+ const seq = edits.get(id);
+ const session = await hydrate(p.items, id);
+ // Changed here meanwhile, or another project opened: that change is saved and merged instead.
+ if (edits.get(id) !== seq || state.projectId !== id) return;
+ const selected = session.some((i) => i.key === state.selected) ? state.selected : (session.at(-1)?.key ?? null);
+ setState({ session, selected });
+}
+
+/** Removed on another device: out of the list; if it is open, a new project starts. */
+function dropProject(id: string) {
+ delete projects[id];
+ serverKeys.delete(id);
+ dirty.delete(id);
+ if (id === state.projectId) setState((s) => ({ projectId: newKey(), session: [], selected: null, redo: [], composer: emptyComposer(s.composer), projects: projectList() }));
+ else setState({ projects: projectList() });
+}
+
+/** Loads the list from the service; the first time, with this app's own list from before 0.11. */
+export async function loadProjects() {
+ try {
+ const raw = localStorage.getItem(PROJECTS_KEY);
+ const local = raw ? (JSON.parse(raw) as Record<string, ProjectData>) : null;
+ if (local && typeof local === "object") {
+ await api.importProjects(Object.values(local));
+ localStorage.setItem(BACKUP_KEY, raw!);
+ localStorage.removeItem(PROJECTS_KEY);
+ }
+ } catch {
+ /* sent again next start (it stays in storage until the service has it) */
+ }
+ const { projects: list } = await api.projects();
+ const ids = new Set(list.map((p) => p.meta.id));
+ for (const id of Object.keys(projects)) if (!ids.has(id) && !dirty.has(id)) delete projects[id];
+ for (const p of list) await applyProject(p);
+ setState({ projects: projectList() });
+}
+
+/** News from the service: a project changed (on this or another device) or was removed. */
+async function onProjectEvent(id: string, rev: number, deleted: boolean) {
+ if (deleted) {
+ if (projects[id] || serverKeys.has(id)) dropProject(id);
+ return;
+ }
+ if ((projects[id]?.rev ?? 0) >= rev) return;
+ try {
+ await applyProject(await api.project(id));
+ } catch {
+ /* removed meanwhile: its own event follows */
+ }
}
function projectList(): ProjectMeta[] {
@@ -238,15 +329,33 @@ function syncProject(prev: State) {
items,
selected: state.selected,
loras: state.composer.loras ?? undefined,
+ rev: old?.rev,
};
+ // Saved (and heard by the other devices) only when something they show changed.
+ if (content(projects[id]) !== content(old)) persistProjects([id]);
+ else if (old) projects[id].meta.updatedAt = old.meta.updatedAt;
state = { ...state, projects: projectList() };
- persistProjects();
}
-/** Loads the records of a stored project. Versions deleted from the gallery are skipped. */
-async function hydrate(items: StoredItem[]): Promise<SessionItem[]> {
+/** Loads the records of a stored project. Versions deleted from the gallery are skipped.
+ * All of them come in one request (one per version is slow on a phone); against a service
+ * without it, or for versions it did not know yet, one request per version. */
+async function hydrate(items: StoredItem[], projectId?: string): Promise<SessionItem[]> {
+ let gone = new Set<string>();
+ const missing = items.some((it) => (it.kind === "gen" && it.genId && !genCache.has(it.genId)) || (it.kind === "input" && it.inputId && !inputCache.has(it.inputId)));
+ if (projectId && missing) {
+ try {
+ const r = await api.projectRecords(projectId);
+ for (const g of Object.values(r.generations)) genCache.set(g.id, g);
+ for (const i of Object.values(r.inputs)) inputCache.set(i.id, i);
+ gone = goneVersions(items, r, serverKeys.get(projectId) ?? []);
+ } catch {
+ /* an older kokon-service: one request per version below */
+ }
+ }
const out = await Promise.all(
items.map(async (it): Promise<SessionItem | null> => {
+ if (gone.has(it.key)) return null;
try {
if (it.kind === "gen" && it.genId) {
const g = genCache.get(it.genId) ?? (await api.generation(it.genId));
@@ -451,6 +560,7 @@ export function startEvents() {
if (loaded) refreshStatus();
}
else if (ev.type === "gallery") setState((s) => ({ galleryVersion: s.galleryVersion + 1 }));
+ else if (ev.type === "projects") onProjectEvent(ev.id, ev.rev, ev.deleted);
},
(ok) => {
setState({ connected: ok });
@@ -458,6 +568,8 @@ export function startEvents() {
// Catch up on anything missed while disconnected.
api.jobs().then((js) => js.forEach(onJob)).catch(() => {});
refreshStatus();
+ // Changes made elsewhere meanwhile, then this app's own that could not be saved.
+ loadProjects().then(flushProjects, () => {});
}
},
);
@@ -485,7 +597,9 @@ function onJob(job: JobView) {
setState((s) => {
const jobs = { ...s.jobs, [job.id]: job };
if (job.status !== "done") return { jobs };
- const results = job.results.map((g): SessionItem => ({ key: newKey(), kind: "gen", gen: g, jobId: job.id }));
+ // Keys from the image ids, the same the service gives them (projects.rs `job_done`), so a
+ // result added by both, or by two devices, is one version.
+ const results = job.results.map((g): SessionItem => ({ key: `r-${g.id}`, kind: "gen", gen: g, jobId: job.id }));
// Replace the pending version with one version per result.
const idx = s.session.findIndex((i) => i.jobId === job.id && i.kind === "job");
if (idx >= 0) {
@@ -512,8 +626,8 @@ function onJob(job: JobView) {
const wasSelected = p.selected === p.items[k].key;
p.items = [...p.items.slice(0, k), ...stored, ...p.items.slice(k + 1)];
if (wasSelected && stored[0]) p.selected = stored[0].key;
+ // Shown at once; the service made the same change and saves it (no save from here).
p.meta = { ...p.meta, cover: lastCover(p.items), count: countOf(p.items), updatedAt: Date.now() };
- persistProjects();
return { jobs, projects: projectList() };
}
// A job from another client (e.g. MCP): track it but do not add it to a project.
@@ -642,7 +756,7 @@ export function setProjectLoras(ids: string[]) {
const p = projects[state.projectId];
if (p && !state.privateMode) {
p.loras = ids;
- persistProjects();
+ persistProjects([p.meta.id]);
}
}
@@ -666,19 +780,22 @@ export async function addExampleProjects(): Promise<string | null> {
const { projects: examples } = await api.installExamples();
const now = Date.now();
let first: string | null = null;
+ const added: string[] = [];
examples.forEach((ex, i) => {
const have = Object.values(projects).find((p) => p.items.some((it) => it.genId === ex.generations[0]));
if (have) {
first ??= have.meta.id;
return;
}
- const id = newKey();
- const items: StoredItem[] = ex.generations.map((g) => ({ key: newKey(), kind: "gen", genId: g }));
+ // Ids from the images: two devices adding them at once make the same projects.
+ const id = `ex-${ex.generations[0]}`;
+ const items: StoredItem[] = ex.generations.map((g) => ({ key: `ex-${g}`, kind: "gen", genId: g }));
const updatedAt = now - 60_000 - i * 1000;
projects[id] = { meta: { id, title: ex.title, named: true, updatedAt, cover: lastCover(items), count: items.length }, items, selected: items[items.length - 1].key };
first ??= id;
+ added.push(id);
});
- persistProjects();
+ persistProjects(added);
setState({ projects: projectList() });
return first;
}
@@ -714,7 +831,7 @@ export function renameProject(id: string, name: string) {
const auto = id === state.projectId ? titleOf(state.session) : null;
p.meta = title ? { ...p.meta, title, named: true } : { ...p.meta, title: auto ?? p.meta.title ?? "Untitled", named: false };
projects[id] = p;
- persistProjects();
+ persistProjects([id]);
setState({ projects: projectList() });
}
@@ -725,8 +842,11 @@ export function deleteProject(id: string) {
/** Removes projects from the list (their images stay in All images); the open one closes. */
export function deleteProjects(ids: string[]) {
- for (const id of ids) delete projects[id];
- persistProjects();
+ for (const id of ids) {
+ delete projects[id];
+ dirty.delete(id);
+ if (serverKeys.delete(id)) api.deleteProject(id).catch(toastError);
+ }
if (ids.includes(state.projectId)) setState((s) => ({ projectId: newKey(), session: [], selected: null, composer: emptyComposer(s.composer), projects: projectList() }));
else setState({ projects: projectList() });
}
@@ -774,12 +894,14 @@ export async function openGeneration(g: GenerationRecord) {
/** A generation was deleted: drop it from every project. */
export function forgetGeneration(id: string) {
genCache.delete(id);
+ const changed: string[] = [];
for (const p of Object.values(projects)) {
if (!p.items.some((i) => i.genId === id)) continue;
p.items = p.items.filter((i) => i.genId !== id);
p.meta = { ...p.meta, cover: lastCover(p.items), count: countOf(p.items) };
+ changed.push(p.meta.id);
}
- persistProjects();
+ persistProjects(changed);
setState((s) => {
const session = s.session.filter((i) => i.gen?.id !== id);
const refs = s.composer.refs.filter((r) => r.source !== `gen:${id}`);
diff --git a/src/lib/types.ts b/src/lib/types.ts
index aaaf8f2..43a3c9d 100644
--- a/src/lib/types.ts
+++ b/src/lib/types.ts
@@ -436,4 +436,5 @@ export interface HardwareReport {
export type ServiceEvent =
| { type: "job"; job: JobView }
| { type: "server"; state: ServerState; owned: boolean; error: AppErrorBody | null }
- | { type: "gallery"; id: string; change: "added" | "updated" | "deleted" };
+ | { type: "gallery"; id: string; change: "added" | "updated" | "deleted" }
+ | { type: "projects"; id: string; rev: number; deleted: boolean };