for mac use regular titlebar

- simplified adding models (use **Models.ts** to add more models)

.github/workflows/artcraft-windows-publish.yml

@@ -26,14 +26,23 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
+      - name: install Rust stable
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: install wreq dependencies
+        run: |
+          choco install cmake -y
+          choco install strawberryperl -y
+          choco install pkgconfiglite -y
+          choco install llvm -y
+          choco install nasm -y
+        shell: cmd
+
       - name: setup node
         uses: actions/setup-node@v4
         with:
           node-version: lts/*
 
-      - name: install Rust stable
-        uses: dtolnay/rust-toolchain@stable
-
       - name: install frontend dependencies
         run: |
           # Navigate to the frontend directory to install dependencies
@@ -83,6 +92,8 @@ jobs:
       - name: build and publish
         uses: tauri-apps/tauri-action@v0
         env:
+          # NB(bt): This is needed by wreq. Hopefully it doesn't kill Tauri
+          RUSTFLAGS: "-C target-feature=+crt-static"
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           # Use the SQLx query cache for SQLite
           SQLX_OFFLINE: true

.sqlx/query-28cac5883464613d29bedbf7308a71c258f1bf4abb8f5ca3ae320db34c137955.json

@@ -1,12 +0,0 @@
-{
-  "db_name": "MySQL",
-  "query": "\nINSERT INTO media_files\nSET\n  token = ?,\n\n  media_class = ?,\n  media_type = ?,\n\n  origin_category = ?,\n  origin_product_category = ?,\n\n  maybe_engine_category = ?,\n  maybe_animation_type = ?,\n\n  maybe_mime_type = ?,\n  file_size_bytes = ?,\n\n  checksum_sha2 = ?,\n\n  maybe_title = ?,\n  maybe_duration_millis = ?,\n\n  public_bucket_directory_hash = ?,\n  maybe_public_bucket_prefix = ?,\n  maybe_public_bucket_extension = ?,\n\n  maybe_creator_user_token = ?,\n  maybe_creator_anonymous_visitor_token = ?,\n  creator_ip_address = ?,\n\n  creator_set_visibility = ?,\n\n  maybe_scene_source_media_file_token = ?,\n  is_intermediate_system_file = ?,\n\n  maybe_creator_file_synthetic_id = ?,\n  maybe_creator_category_synthetic_id = ?,\n\n  is_user_upload = TRUE,\n\n  maybe_origin_model_type = NULL,\n  maybe_origin_model_token = NULL\n        ",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Right": 23
-    },
-    "nullable": []
-  },
-  "hash": "28cac5883464613d29bedbf7308a71c258f1bf4abb8f5ca3ae320db34c137955"
-}

.sqlx/query-e86494c0a53247903aa58009e2a26c4db90a89e9f6ea805ffb3929faf69a431d.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "MySQL",
+  "query": "\nINSERT INTO media_files\nSET\n  token = ?,\n\n  media_class = ?,\n  media_type = ?,\n\n  origin_category = ?,\n  origin_product_category = ?,\n\n  maybe_engine_category = ?,\n  maybe_animation_type = ?,\n\n  maybe_mime_type = ?,\n  file_size_bytes = ?,\n\n  checksum_sha2 = ?,\n\n  maybe_prompt_token = ?,\n\n  maybe_title = ?,\n  maybe_duration_millis = ?,\n\n  public_bucket_directory_hash = ?,\n  maybe_public_bucket_prefix = ?,\n  maybe_public_bucket_extension = ?,\n\n  maybe_creator_user_token = ?,\n  maybe_creator_anonymous_visitor_token = ?,\n  creator_ip_address = ?,\n\n  creator_set_visibility = ?,\n\n  maybe_scene_source_media_file_token = ?,\n  is_intermediate_system_file = ?,\n\n  maybe_creator_file_synthetic_id = ?,\n  maybe_creator_category_synthetic_id = ?,\n\n  is_user_upload = TRUE,\n\n  maybe_origin_model_type = NULL,\n  maybe_origin_model_token = NULL\n        ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 24
+    },
+    "nullable": []
+  },
+  "hash": "e86494c0a53247903aa58009e2a26c4db90a89e9f6ea805ffb3929faf69a431d"
+}

Cargo.toml

@@ -10,6 +10,7 @@ members = [
   "crates/api_clients/fal_client",
   "crates/api_clients/google_drive_common",
   "crates/api_clients/google_sign_in",
+  "crates/api_clients/midjourney_client",
   "crates/api_clients/openai_sora_client",
   "crates/api_clients/openart_client",
   "crates/api_clients/runwayml_client",
@@ -42,6 +43,7 @@ members = [
   "crates/lib/caching/redis_caching",
   "crates/lib/cloudflare_errors",
   "crates/lib/concurrency",
+  "crates/lib/cookie_store",
   "crates/lib/cookies",
   "crates/lib/data/collections",
   "crates/lib/data/crockford",
@@ -199,7 +201,8 @@ log = "0.4.27"
 once_cell = "1.21.3"
 rand = "0.9.1"
 regex = "1.11.1"
-reqwest = { version = "0.12.15", features = ["json", "cookies"] }
+reqwest = { version = "0.12.22", features = ["json", "cookies"] }
+reqwest-websocket = {  version = "0.5.0" }
 serde = {  version = "1.0.219", features = ["derive"] }
 serde_derive = "1.0.219"
 serde_json = "1.0.140"
@@ -218,6 +221,7 @@ artcraft_api_defs = { path = "crates/schema/public/api/artcraft_api_defs" }
 build_metadata = { path = "crates/lib/build_metadata" }
 cloud_storage = { path = "crates/api_clients/cloud_storage" }
 cloudflare_errors = { path = "crates/lib/cloudflare_errors" }
+cookie_store = { path = "crates/lib/cookie_store" }
 crockford = { path = "crates/lib/data/crockford" }
 enums = { path = "crates/schema/public/enums" }
 enums_public = { path = "crates/schema/public/enums_public" }
@@ -230,6 +234,7 @@ images = { path = "crates/lib/files/images" }
 jwt_light = { path = "crates/lib/jwt_light" }
 memory_caching = { path = "crates/lib/caching/memory_caching" }
 memory_store = { path = "crates/lib/caching/memory_store" }
+midjourney_client = { path = "crates/api_clients/midjourney_client" }
 mimetypes = { path = "crates/lib/files/mimetypes" }
 openai_sora_client = { path = "crates/api_clients/openai_sora_client" }
 primitives = { path = "crates/lib/data/primitives" }
@@ -238,5 +243,6 @@ sqlite_tasks = { path = "crates/schema/database/sqlite_tasks" }
 storyteller_client = { path = "crates/api_clients/storyteller_client" }
 subprocess_common = { path = "crates/lib/subprocess_common" }
 test_data = { path = "crates/lib/test_data" }
+testing = { path = "crates/lib/testing" }
 tokens = { path = "crates/schema/public/tokens" }
 web_base64 = { path = "crates/lib/data/web_base64" }

_sql/artcraft_migrations/20250708000000_create_tasks_table.sql

@@ -1,7 +1,14 @@
 -- noinspection SqlDialectInspectionForFile
+--
+-- NB: This version needs to be bumped even if just adding or changing comments!
+--  Failure to do so will cause Windows to segfault at start. (This is horrible!)
+--
+-- NB: `app_state_dir.rs` contains the file version number.
+--
 -- Migration history:
 --   tasks_v1.sqlite - initial version
 --   tasks_v2.sqlite - added model_type (nullable)
+--   tasks_v3.sqlite - added frontend_caller, comments
 
 CREATE TABLE tasks (
     -- Task auto-incrementing primary key.

crates/api_clients/midjourney_client/Cargo.toml

@@ -0,0 +1,55 @@
+[package]
+name = "midjourney_client"
+edition = "2024"
+version = "0.0.1"
+publish = false
+
+[package.metadata.cargo-udeps.ignore]
+normal = ["workspace-build-acceleration"]
+
+[lib]
+name = "midjourney_client"
+path = "src/lib.rs"
+
+[dependencies]
+# Workspace hack (faster compile times)
+workspace-build-acceleration.workspace = true
+
+# Internal
+cloudflare_errors.workspace = true
+cookie_store.workspace = true
+errors.workspace = true
+
+# External
+anyhow.workspace = true
+futures.workspace = true
+log.workspace = true
+#reqwest-websocket.workspace = true
+#reqwest.workspace = true
+#reqwest-impersonate = { version = "0", features = ["websocket"] }
+serde.workspace = true
+serde_json.workspace = true
+#tokio.workspace = true
+url.workspace = true
+
+# NB: wreq gets past fingerprinting, but we have to deal with platform-specific build issues.
+#
+# Mac:
+#   brew install --formula cmake pkg-config llvm
+# Windows:
+#   choco install cmake -y
+#   choco install strawberryperl -y
+#   choco install pkgconfiglite -y
+#   choco install llvm -y
+#   choco install nasm -y
+wreq = { version = "5", features = ["json"] }
+wreq-util = "2"
+tokio = { version = "1", features = ["full"] }
+
+# NB: We need to parse HTML to get out the websocket token
+dom_query = "0.20.2"
+
+[dev-dependencies]
+filesys.workspace = true
+test_data.workspace = true
+testing.workspace = true

crates/api_clients/midjourney_client/src/client/midjourney_hostname.rs

@@ -0,0 +1,17 @@
+
+/// Multiple third party Midjourney clients make this configurable.
+/// Not sure why, I'm just cargo culting it.
+#[derive(Clone)]
+pub enum MidjourneyHostname {
+  Standard,
+  Custom(String),
+}
+
+impl MidjourneyHostname {
+  pub fn as_str(&self) -> &str {
+    match self {
+      Self::Standard => "www.midjourney.com",
+      Self::Custom(domain) => domain,
+    }
+  }
+}

crates/api_clients/midjourney_client/src/client/mod.rs

@@ -0,0 +1,2 @@
+pub mod midjourney_hostname;
+pub mod midjourney_websocket_client;

crates/api_clients/midjourney_client/src/credentials/cookie_names.rs

@@ -0,0 +1,6 @@
+
+/// One of the apparent authentication cookies used by Midjourney.
+pub (crate) const AUTH_COOKIE_NAME_R : &str = "__Host-Midjourney.AuthUserTokenV3_r";
+
+/// One of the apparent authentication cookies used by Midjourney.
+pub (crate) const AUTH_COOKIE_NAME_I : &str = "__Host-Midjourney.AuthUserTokenV3_i";

crates/api_clients/midjourney_client/src/credentials/cookie_store_has_auth_cookies.rs

@@ -0,0 +1,8 @@
+use crate::credentials::cookie_names::{AUTH_COOKIE_NAME_I, AUTH_COOKIE_NAME_R};
+use cookie_store::cookie_store::CookieStore;
+
+/// Returns true if the given cookie store has the necessary authentication cookies.
+pub fn cookie_store_has_auth_cookies(cookie_store: &CookieStore) -> bool {
+  cookie_store.has_cookie(AUTH_COOKIE_NAME_I)
+      && cookie_store.has_cookie(AUTH_COOKIE_NAME_R)
+}

crates/api_clients/midjourney_client/src/credentials/jwt_decode.rs

@@ -0,0 +1,31 @@
+
+/*
+{
+  "name": "u3869671173",
+  "picture": "https://lh3.googleusercontent.com/a/ACg8ocKw0aaXKYSqy-Xkkn69ydIJFGnJA37S13XvjNY4d9xCzUzKUw=s96-c",
+  "midjourney_id": "f8a57ac3-e416-4dd4-9be8-2c4223691b01",
+  "iss": "https://securetoken.google.com/authjourney",
+  "aud": "authjourney",
+  "auth_time": 1754970849,
+  "user_id": "bS9idl73DlSbE61KnCyKpDfazCX2",
+  "sub": "bS9idl73DlSbE61KnCyKpDfazCX2",
+  "iat": 1754970849,
+  "exp": 1754974449,
+  "email": "victorvoice89@gmail.com",
+  "email_verified": true,
+  "firebase": {
+    "identities": {
+      "google.com": [
+        "116459300198619888836"
+      ],
+      "email": [
+        "victorvoice89@gmail.com"
+      ]
+    },
+    "sign_in_provider": "google.com"
+  }
+}
+*/
+
+/*
+ */

crates/api_clients/midjourney_client/src/credentials/midjourney_user_id.rs

@@ -0,0 +1,22 @@
+
+/// The user ID used for several midjourney requests.
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct MidjourneyUserId(pub String);
+
+impl MidjourneyUserId {
+  pub fn from_str(user_id: &str) -> Self {
+    Self(user_id.to_string())
+  }
+  
+  pub fn from_string(user_id: String) -> Self {
+    Self(user_id)
+  }
+
+  pub fn as_str(&self) -> &str {
+    &self.0
+  }
+  
+  pub fn to_string(&self) -> String {
+    self.0.to_string()
+  }
+}

crates/api_clients/midjourney_client/src/credentials/mod.rs

@@ -0,0 +1,4 @@
+pub mod cookie_names;
+pub mod cookie_store_has_auth_cookies;
+pub mod jwt_decode;
+pub mod midjourney_user_id;

crates/api_clients/midjourney_client/src/endpoints/get_index_page_html.rs

@@ -0,0 +1,95 @@
+use crate::client::midjourney_hostname::MidjourneyHostname;
+use crate::error::midjourney_api_error::MidjourneyApiError;
+use crate::error::midjourney_client_error::MidjourneyClientError;
+use crate::error::midjourney_error::MidjourneyError;
+use cloudflare_errors::filter_cloudflare_errors::filter_cloudflare_errors;
+use log::error;
+use serde::Deserialize;
+use wreq::Client;
+use wreq_util::Emulation;
+
+/// This grabs the pre-rendered HTML page, which contains the websocket token and other details.
+pub struct GetIndexPageRequest {
+  pub hostname: MidjourneyHostname,
+  pub cookie_header: String,
+}
+
+pub async fn get_index_page_html(req: GetIndexPageRequest) -> Result<String, MidjourneyError> {
+  let url = format!("https://{}/", req.hostname.as_str());
+
+  let client = Client::builder()
+      .emulation(Emulation::Firefox139)
+      .build()
+      .map_err(|err| MidjourneyClientError::WreqError(err))?;
+
+  let cookie_header = req.cookie_header.trim();
+
+  if cookie_header.len() < 20 {
+    error!("Cookie header is too short (len: {}): {}", cookie_header.len(), cookie_header);
+    return Err(MidjourneyClientError::CookieTooShort.into());
+  }
+
+  // NB: missing headers that were in the browser request:
+  // -H 'sec-ch-ua-platform: "macOS"' \
+  // -H 'sec-ch-ua: "Not)A;Brand";v="8", "Chromium";v="138", "Google Chrome";v="138"' \
+
+  let mut http_request = client.get(url)
+      .header("cookie", cookie_header)
+      .header("Referrer-Policy", "origin-when-cross-origin")
+      .header("accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7")
+      .header("accept-language", "en-US,en;q=0.8")
+      .header("content-type", "application/json")
+      .header("priority", "u=0, i")
+      .header("sec-ch-ua-mobile", "?0")
+      .header("sec-fetch-dest", "document")
+      .header("sec-fetch-mode", "navigate")
+      .header("sec-fetch-site", "none")
+      .header("sec-fetch-user", "?1")
+      .header("upgrade-insecure-requests", "1");
+
+  let http_request  = http_request
+      .build()
+      .map_err(|err| MidjourneyClientError::WreqError(err))?;
+
+  let response = client.execute(http_request)
+      .await
+      .map_err(|e| MidjourneyApiError::NetworkError(e.to_string()))?;
+
+  let status = response.status();
+
+  let response_body = response.text().await
+      .map_err(|e| MidjourneyApiError::NetworkError(e.to_string()))?;
+
+  if !status.is_success() {
+    if let Err(err) = filter_cloudflare_errors(status.as_u16(), &response_body) {
+      return Err(MidjourneyApiError::CloudflareError(err).into());
+    }
+  }
+  
+  Ok(response_body)
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::client::midjourney_hostname::MidjourneyHostname;
+  use errors::AnyhowResult;
+  use filesys::read_to_trimmed_string::read_to_trimmed_string;
+  use crate::endpoints::get_index_page_html::{get_index_page_html, GetIndexPageRequest};
+
+  #[ignore]
+  #[tokio::test]
+  async fn test() -> AnyhowResult<()> {
+    let cookie_header = read_to_trimmed_string("/Users/bt/secrets/midjourney/cookie.txt")?;
+
+    let result = get_index_page_html(GetIndexPageRequest {
+      cookie_header,
+      hostname: MidjourneyHostname::Standard,
+    }).await?;
+
+    println!("Response: {:?}\n\n", result);
+
+    assert_eq!(1, 2);
+
+    Ok(())
+  }
+}

crates/api_clients/midjourney_client/src/endpoints/imagine.rs

@@ -0,0 +1,251 @@
+use crate::client::midjourney_hostname::MidjourneyHostname;
+use crate::credentials::midjourney_user_id::MidjourneyUserId;
+use crate::error::midjourney_api_error::MidjourneyApiError;
+use crate::error::midjourney_client_error::MidjourneyClientError;
+use crate::error::midjourney_error::MidjourneyError;
+use cloudflare_errors::filter_cloudflare_errors::filter_cloudflare_errors;
+use log::error;
+use serde::Deserialize;
+use wreq::Client;
+use wreq_util::Emulation;
+
+const DEFAULT_PAGE_SIZE : u64 = 1000;
+
+/// This returns Midjourney's job/media list
+pub struct ImagineRequest<'a> {
+  pub hostname: MidjourneyHostname,
+  pub cookie_header: String,
+  pub user_id: &'a MidjourneyUserId,
+  pub page_size: Option<u64>,
+}
+
+#[derive(Debug, Clone)]
+pub struct ImagineResponse {
+  pub items: Vec<ImagineItem>,
+  pub cursor: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct ImagineItem {
+  pub id: Option<String>,
+
+  /// This is the prompt, e.g.
+  /// `cute puppy wearing a polar bear suit --ar 4:3 --raw --v 7.0`
+  pub full_command: Option<String>,
+
+  pub job_type: Option<MidjourneyJobType>,
+}
+
+#[derive(Debug, Clone)]
+pub enum MidjourneyJobType {
+  V6Diffusion,
+  V6p1Diffusion,
+  V6p1RawDiffusion,
+  V7Diffusion,
+  V7DraftDiffusion,
+  V7DraftRawDiffusion,
+  V7RawDiffusion,
+  Vid11I2vRenderAJointVideo,
+  Vid11I2vRenderBJointVideo,
+  Vid11I2vStartEndAVideo,
+  Vid11I2vStartEndBVideo,
+  Other(String),
+}
+
+impl MidjourneyJobType {
+  pub fn from_str(s: &str) -> MidjourneyJobType {
+    match s {
+      "v6_diffusion" => MidjourneyJobType::V6Diffusion,
+      "v6-1_diffusion" => MidjourneyJobType::V6p1Diffusion,
+      "v6-1_raw_diffusion" => MidjourneyJobType::V6p1RawDiffusion,
+      "v7_diffusion" => MidjourneyJobType::V7Diffusion,
+      "v7_draft_diffusion" => MidjourneyJobType::V7DraftDiffusion,
+      "v7_draft_raw_diffusion" => MidjourneyJobType::V7DraftRawDiffusion,
+      "v7_raw_diffusion" => MidjourneyJobType::V7RawDiffusion,
+      "vid_1.1_i2v_render_a_joint_video" => MidjourneyJobType::Vid11I2vRenderAJointVideo,
+      "vid_1.1_i2v_render_b_joint_video" => MidjourneyJobType::Vid11I2vRenderBJointVideo,
+      "vid_1.1_i2v_start_end_a_video" => MidjourneyJobType::Vid11I2vStartEndAVideo,
+      "vid_1.1_i2v_start_end_b_video" => MidjourneyJobType::Vid11I2vStartEndBVideo,
+      other => MidjourneyJobType::Other(other.to_string()),
+    }
+  }
+}
+
+pub async fn imagine(req: ImagineRequest<'_>) -> Result<ImagineResponse, MidjourneyError> {
+  let cookie_header = req.cookie_header.trim();
+
+  if cookie_header.len() < 20 {
+    error!("Cookie header is too short (len: {}): {}", cookie_header.len(), cookie_header);
+    return Err(MidjourneyClientError::CookieTooShort.into());
+  }
+
+  let page_size = req.page_size.unwrap_or(DEFAULT_PAGE_SIZE);
+
+  let referer = format!("https://{}/imagine", req.hostname.as_str());
+
+  let url = format!("https://{}/api/imagine?user_id={}&page_size={}",
+    req.hostname.as_str(),
+    req.user_id.as_str(),
+    page_size,
+  );
+
+  let client = Client::builder()
+      .emulation(Emulation::Firefox139)
+      .build()
+      .map_err(|err| MidjourneyClientError::WreqError(err))?;
+
+  // NB: missing headers that were in the browser request:
+  // -H 'sec-ch-ua-platform: "macOS"' \
+  // -H 'sec-ch-ua: "Not)A;Brand";v="8", "Chromium";v="138", "Google Chrome";v="138"' \
+
+  let mut http_request = client.get(url)
+      .header("cookie", cookie_header)
+      .header("Referer", &referer)
+      .header("Referrer-Policy", "origin-when-cross-origin")
+      .header("accept", "*/*")
+      .header("accept-encoding", "gzip, deflate, br, zstd")
+      .header("accept-language", "en-US,en;q=0.8")
+      .header("content-type", "application/json")
+      .header("priority", "u=1, i")
+      .header("sec-ch-ua-mobile", "?0")
+      .header("sec-fetch-dest", "empty")
+      .header("sec-fetch-mode", "cors")
+      .header("sec-fetch-site", "same-origin")
+      .header("x-csrf-protection", "1");
+
+  let http_request  = http_request
+      .build()
+      .map_err(|err| MidjourneyClientError::WreqError(err))?;
+
+  let response = client.execute(http_request)
+      .await
+      .map_err(|e| MidjourneyApiError::NetworkError(e.to_string()))?;
+
+  let status = response.status();
+
+  let response_body = response.text().await
+      .map_err(|e| MidjourneyApiError::NetworkError(e.to_string()))?;
+
+  if !status.is_success() {
+    if let Err(err) = filter_cloudflare_errors(status.as_u16(), &response_body) {
+      return Err(MidjourneyApiError::CloudflareError(err).into());
+    }
+  }
+
+  /*
+  {
+    "data": [
+        {
+            "id": "a2339f14-ff71-43e4-a69f-8da15e7ba871",
+            "enqueue_time": "2025-08-14T17:21:28.403560+00:00",
+            "parent_id": null,
+            "video_segments": null,
+            "rating": null,
+            "job_type": "v7_diffusion",
+            "event_type": "diffusion",
+            "parent_grid": null,
+            "full_command": "a modern n64 console",
+            "batch_size": 4,
+            "width": 1024,
+            "height": 1024,
+            "published": true,
+            "shown": true,
+            "user_hidden": false,
+            "template": null,
+            "vid_framecount": null
+        },
+      ],
+      "cursor": "encrypted cursor",
+      "checkpoint": "encrypted something ???"
+    }
+   */
+
+
+  #[derive(Deserialize, Debug)]
+  #[allow(non_snake_case)]
+  struct RawImagineResponse {
+    data: Vec<RawImagineItem>,
+    cursor: Option<String>,
+    //pub checkpoint: Option<String>,
+  }
+
+  #[derive(Deserialize, Debug)]
+  #[allow(non_snake_case)]
+  struct RawImagineItem {
+    // The job id
+    id: Option<String>,
+
+    // The prompt plus `--` args.
+    full_command: Option<String>,
+
+    // Number of images, typically 4
+    batch_size: Option<u8>,
+
+    // Some possible values:
+    // "v6_diffusion"
+    // "v7_diffusion"
+    // "v7_draft_raw_diffusion"
+    // "v7_raw_diffusion"
+    // "vid_1.1_i2v_render_b_joint_video",
+    // "vid_1.1_i2v_start_end_a_video"
+    // "vid_1.1_i2v_start_end_b_video"
+    job_type: Option<String>,
+
+    // Some possible values:
+    // "diffusion"
+    // "draft"
+    // "variation"
+    // "video_diffusion"
+    // "video_start_end"
+    event_type: Option<String>,
+  }
+
+  let response : RawImagineResponse = serde_json::from_str(&response_body)
+      .map_err(|err| MidjourneyApiError::DeserializationError(err))?;
+
+  Ok(ImagineResponse {
+    cursor: response.cursor.clone(),
+    items: response.data
+        .into_iter()
+        .map(|item| {
+          ImagineItem {
+            id: item.id,
+            full_command: item.full_command,
+            job_type: item.job_type.as_ref()
+                .map(|jt| MidjourneyJobType::from_str(jt))
+          }
+        }).collect(),
+  })
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::client::midjourney_hostname::MidjourneyHostname;
+  use crate::credentials::midjourney_user_id::MidjourneyUserId;
+  use crate::endpoints::imagine::{imagine, ImagineRequest};
+  use errors::AnyhowResult;
+  use filesys::read_to_trimmed_string::read_to_trimmed_string;
+
+  #[ignore]
+  #[tokio::test]
+  async fn test() -> AnyhowResult<()> {
+    let cookie_header = read_to_trimmed_string("/Users/bt/secrets/midjourney/cookie.txt")?;
+    let user_id = read_to_trimmed_string("/Users/bt/secrets/midjourney/user_id.txt")?;
+    let user_id = MidjourneyUserId::from_string(user_id);
+
+    let result = imagine(ImagineRequest {
+      cookie_header,
+      hostname: MidjourneyHostname::Standard,
+      user_id: &user_id,
+      page_size: None,
+    }).await?;
+
+    println!("Response: {:?}\n\n", result);
+
+    assert_eq!(1, 2);
+
+    Ok(())
+  }
+}
+
+

crates/api_clients/midjourney_client/src/endpoints/mod.rs

@@ -0,0 +1,5 @@
+pub mod get_index_page_html;
+pub mod imagine;
+pub mod storage_list;
+pub mod submit_job;
+pub mod user_connections;

crates/api_clients/midjourney_client/src/endpoints/storage_list.rs

@@ -0,0 +1,147 @@
+use crate::client::midjourney_hostname::MidjourneyHostname;
+use crate::error::midjourney_api_error::MidjourneyApiError;
+use crate::error::midjourney_client_error::MidjourneyClientError;
+use crate::error::midjourney_error::MidjourneyError;
+use cloudflare_errors::filter_cloudflare_errors::filter_cloudflare_errors;
+use log::error;
+use serde::Deserialize;
+use wreq::Client;
+use wreq_util::Emulation;
+
+/// This endpoint returns the user id
+pub struct GetStorageListRequest {
+  pub hostname: MidjourneyHostname,
+  pub cookie_header: String,
+}
+
+#[derive(Debug)]
+pub struct StorageItem {
+  // NB: The path contains the user ID.
+  pub bucket_pathname: Option<String>,
+
+  // NB: Other fields aren't necessary for us right now.
+}
+
+pub async fn storage_list(req: GetStorageListRequest) -> Result<Vec<StorageItem>, MidjourneyError> {
+
+  let referer = format!("https://{}", req.hostname.as_str());
+
+  let url = format!("https://{}/api/storage-list", req.hostname.as_str());
+
+  let client = Client::builder()
+      .emulation(Emulation::Firefox139)
+      .build()
+      .map_err(|err| MidjourneyClientError::WreqError(err))?;
+
+  let cookie_header = req.cookie_header.trim();
+
+  if cookie_header.len() < 20 {
+    error!("Cookie header is too short (len: {}): {}", cookie_header.len(), cookie_header);
+    return Err(MidjourneyClientError::CookieTooShort.into());
+  }
+
+  // NB: missing headers that were in the browser request:
+  // -H 'sec-ch-ua-platform: "macOS"' \
+  // -H 'sec-ch-ua: "Not)A;Brand";v="8", "Chromium";v="138", "Google Chrome";v="138"' \
+
+  let mut http_request = client.get(url)
+      .header("cookie", cookie_header)
+      .header("Referer", &referer)
+      .header("Referrer-Policy", "origin-when-cross-origin")
+      .header("accept", "*/*")
+      .header("accept-language", "en-US,en;q=0.8")
+      .header("content-type", "application/json")
+      .header("priority", "u=1, i")
+      .header("sec-ch-ua-mobile", "?0")
+      .header("sec-fetch-dest", "empty")
+      .header("sec-fetch-mode", "cors")
+      .header("sec-fetch-site", "same-origin")
+      .header("x-csrf-protection", "1");
+
+  let http_request  = http_request
+      .build()
+      .map_err(|err| MidjourneyClientError::WreqError(err))?;
+
+  let response = client.execute(http_request)
+      .await
+      .map_err(|e| MidjourneyApiError::NetworkError(e.to_string()))?;
+
+  let status = response.status();
+
+  // if status == 301 {
+  //   for (name, value) in response.headers().iter() {
+  //     println!("- {}: {}", name.as_str(), value.to_str().unwrap());
+  //   }
+  // }
+
+  let response_body = &response.text().await
+      .map_err(|e| MidjourneyApiError::NetworkError(e.to_string()))?;
+
+  if !status.is_success() {
+    if let Err(err) = filter_cloudflare_errors(status.as_u16(), &response_body) {
+      return Err(MidjourneyApiError::CloudflareError(err).into());
+    }
+  }
+
+  /*
+  [
+      {
+          "bucketPathname": "UUID/OTHER_HEX_ENTROPY.png",
+          "shortUrl": null,
+          "type": "image-prompt",
+          "origin": "web",
+          "timeCreated": TIMESTAMP,
+          "hidden": false,
+          "contentType": "image/png",
+          "state": "loaded"
+      }
+  ]
+  */
+
+  #[derive(Deserialize, Debug)]
+  #[allow(non_snake_case)]
+  struct RawStorageItem {
+    bucketPathname: Option<String>,
+  }
+
+  let response : Vec<RawStorageItem> = serde_json::from_str(response_body)
+      .map_err(|err| MidjourneyApiError::DeserializationError(err))?;
+
+  let items = response
+      .into_iter()
+      .map(|r| StorageItem {
+        bucket_pathname: r.bucketPathname,
+      })
+      .collect::<Vec<_>>();
+
+  Ok(items)
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::client::midjourney_hostname::MidjourneyHostname;
+  use errors::AnyhowResult;
+  use filesys::read_to_trimmed_string::read_to_trimmed_string;
+  use crate::endpoints::storage_list::{storage_list, GetStorageListRequest};
+
+  #[ignore]
+  #[tokio::test]
+  async fn test() -> AnyhowResult<()> {
+    let cookie_header = read_to_trimmed_string("/Users/bt/secrets/midjourney/cookie.txt")?;
+
+    let result = storage_list(GetStorageListRequest {
+      cookie_header,
+      hostname: MidjourneyHostname::Standard,
+    }).await?;
+
+    println!("Response: {:?}\n\n", result);
+
+    for provider in result {
+      println!("Provider: {:?}", provider);
+    }
+
+    assert_eq!(1, 2);
+
+    Ok(())
+  }
+}

crates/api_clients/midjourney_client/src/endpoints/submit_job.rs

@@ -0,0 +1,230 @@
+use crate::error::midjourney_api_error::MidjourneyApiError;
+use crate::error::midjourney_client_error::MidjourneyClientError;
+use crate::error::midjourney_error::MidjourneyError;
+use log::{error, warn};
+use serde::{Deserialize, Serialize};
+
+use crate::client::midjourney_hostname::MidjourneyHostname;
+use cloudflare_errors::filter_cloudflare_errors::filter_cloudflare_errors;
+use wreq::Client;
+use wreq_util::Emulation;
+
+pub struct SubmitJobRequest<'a> {
+  pub prompt: &'a str,
+  pub channel_id: &'a str,
+  pub hostname: MidjourneyHostname,
+  pub cookie_header: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct SubmitJobResponse {
+  /// On success, the job ID is returned.
+  pub maybe_job_id: Option<String>,
+  
+  /// On error, we have a list of error messages.
+  pub maybe_errors: Option<Vec<SubmitJobError>>,
+}
+
+#[derive(Debug, Clone)]
+pub struct SubmitJobError {
+  pub error_type: Option<String>,
+  pub message: Option<String>,
+}
+
+pub async fn submit_job(req: SubmitJobRequest<'_>) -> Result<SubmitJobResponse, MidjourneyError> {
+  let client = Client::builder()
+      .emulation(Emulation::Firefox139)
+      .build()
+      .map_err(|err| MidjourneyClientError::WreqError(err))?;
+
+  let referer = format!("https://{}", req.hostname.as_str());
+
+  // NB: Other recent clients use /api/app/submit-jobs, but this appears invalid.
+  let url = format!("https://{}/api/submit-jobs", req.hostname.as_str());
+
+  let cookie_header = req.cookie_header.trim();
+
+  if cookie_header.len() < 20 {
+    error!("Cookie header is too short (len: {}): {}", cookie_header.len(), cookie_header);
+    return Err(MidjourneyClientError::CookieTooShort.into());
+  }
+
+  let mut http_request = client.post(url)
+      .header("cookie", cookie_header)
+      .header("Referer", &referer)
+      .header("Referrer-Policy", "origin-when-cross-origin")
+      .header("accept", "*/*")
+      .header("accept-language", "en-US,en;q=0.8")
+      .header("content-type", "application/json")
+      .header("priority", "u=1, i")
+      .header("sec-ch-ua-mobile", "?0")
+      .header("sec-fetch-dest", "empty")
+      .header("sec-fetch-mode", "cors")
+      .header("sec-fetch-site", "same-origin")
+      .header("x-csrf-protection", "1");
+
+  #[derive(Serialize)]
+  struct F {
+    mode: String,
+    private: bool,
+  }
+
+  #[derive(Serialize)]
+  #[allow(non_snake_case)]
+  struct Metadata {
+    imagePrompts: u8,
+    imageReferences: u8,
+    characterReferences: u8,
+    depthReferences: u8,
+    lightboxOpen: String,
+  }
+
+  #[derive(Serialize)]
+  #[allow(non_snake_case)]
+  struct RawRequest {
+    f: F,
+    channelId: String,
+    metadata: Metadata,
+    t: String,
+    prompt: String,
+  }
+
+  let body = RawRequest {
+    f: F {
+      mode: "fast".to_string(),
+      private: false,
+    },
+    channelId: req.channel_id.to_string(),
+    metadata: Metadata {
+      imagePrompts: 0,
+      imageReferences: 0,
+      characterReferences: 0,
+      depthReferences: 0,
+      lightboxOpen: "".to_string(),
+    },
+    t: "imagine".to_string(),
+    prompt: req.prompt.to_string(),
+  };
+
+  let http_request  = http_request
+      .json(&body)
+      .build()
+      .map_err(|err| MidjourneyClientError::WreqError(err))?;
+
+  let response = client.execute(http_request)
+      .await
+      .map_err(|e| MidjourneyApiError::NetworkError(e.to_string()))?;
+
+  let status = response.status();
+
+  // if status == 301 {
+  //   for (name, value) in response.headers().iter() {
+  //     println!("- {}: {}", name.as_str(), value.to_str().unwrap());
+  //   }
+  // }
+
+  let response_body = &response.text().await
+      .map_err(|e| MidjourneyApiError::NetworkError(e.to_string()))?;
+
+  if !status.is_success() {
+    if let Err(err) = filter_cloudflare_errors(status.as_u16(), &response_body) {
+      return Err(MidjourneyApiError::CloudflareError(err).into());
+    }
+  }
+
+  /*
+  {"success":[
+    {
+      "job_id":"UUID-like-string",
+      "prompt":"prompt",
+      "is_queued":false,
+      "event_type":"diffusion",
+      "flags":{
+        "mode":"fast","visibility":"public"
+      },
+      "meta":{
+        "height":1024,"width":1024,"batch_size":4,"parent_id":null,"parent_grid":null
+      },
+      "optimisticJobIndex":0,
+      "personalization_codes":null
+    }],
+    "failure":[]}
+   */
+
+  #[derive(Deserialize)]
+  struct SuccessPayload {
+    job_id: String,
+  }
+
+  #[derive(Deserialize)]
+  struct FailurePayload {
+    r#type: String,
+    message: String,
+  }
+
+  #[derive(Deserialize)]
+  #[allow(non_snake_case)]
+  struct RawResponse {
+    success: Vec<SuccessPayload>,
+    failure: Option<Vec<FailurePayload>>,
+  }
+
+  let response = serde_json::from_str::<RawResponse>(response_body)
+      .map_err(|err| MidjourneyApiError::DeserializationError(err))?;
+
+  let maybe_job_id = response.success
+      .get(0)
+      .map(|s| s.job_id.clone());
+  
+  if maybe_job_id.is_none() {
+    warn!("No job id found in body: {:?}", response_body);
+  }
+
+  let mut maybe_errors = None;
+  
+  if let Some(failures) = response.failure.as_ref() {
+    if !failures.is_empty() {
+      maybe_errors = Some(failures.iter()
+          .map(|f| SubmitJobError { 
+            error_type: Some(f.r#type.clone()), 
+            message: Some(f.message.clone()), 
+          }).collect());
+    }
+  }
+
+  Ok(SubmitJobResponse {
+    maybe_job_id,
+    maybe_errors,
+  })
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::client::midjourney_hostname::MidjourneyHostname;
+  use crate::endpoints::submit_job::{submit_job, SubmitJobRequest};
+  use errors::AnyhowResult;
+  use filesys::read_to_trimmed_string::read_to_trimmed_string;
+
+  // Get channel id via:
+  // https://identitytoolkit.googleapis.com/v1/accounts:lookup?key=[TOKEN]
+  #[ignore]
+  #[tokio::test]
+  async fn test() -> AnyhowResult<()> {
+    let cookie_header = read_to_trimmed_string("/Users/bt/secrets/midjourney/cookie.txt")?;
+    let channel_id = read_to_trimmed_string("/Users/bt/secrets/midjourney/channel_id.txt")?;
+
+    let result = submit_job(SubmitJobRequest {
+      prompt: "a modern n64 console",
+      channel_id: &channel_id,
+      cookie_header,
+      hostname: MidjourneyHostname::Standard,
+    }).await?;
+
+    println!("Response: {:?}", result);
+
+    assert_eq!(1, 2);
+
+
+    Ok(())
+  }
+}

crates/api_clients/midjourney_client/src/endpoints/user_connections.rs

@@ -0,0 +1,178 @@
+use crate::client::midjourney_hostname::MidjourneyHostname;
+use crate::error::midjourney_api_error::MidjourneyApiError;
+use crate::error::midjourney_client_error::MidjourneyClientError;
+use crate::error::midjourney_error::MidjourneyError;
+use cloudflare_errors::filter_cloudflare_errors::filter_cloudflare_errors;
+use log::error;
+use serde::Deserialize;
+use wreq::Client;
+use wreq_util::Emulation;
+
+const USER_CONNECTIONS_URL :&str = "https://www.midjourney.com/api/user-connections";
+
+pub struct GetUserConnectionsRequest {
+  pub hostname: MidjourneyHostname,
+  pub cookie_header: String,
+}
+
+#[derive(Debug)]
+pub struct UserData {
+  pub provider_id: String,
+  pub display_name: Option<String>,
+  pub email: Option<String>,
+  pub user_id: Option<String>,
+}
+
+#[derive(Debug)]
+pub struct Provider {
+  pub provider_id: String,
+  pub user_data: Option<UserData>,
+  pub is_linked: bool,
+}
+
+pub async fn user_connections(req: GetUserConnectionsRequest) -> Result<Vec<Provider>, MidjourneyError> {
+
+  let referer = format!("https://{}", req.hostname.as_str());
+
+  let url = format!("https://{}/api/user-connections", req.hostname.as_str());
+
+  let client = Client::builder()
+      .emulation(Emulation::Firefox139)
+      .build()
+      .map_err(|err| MidjourneyClientError::WreqError(err))?;
+
+  let cookie_header = req.cookie_header.trim();
+
+  if cookie_header.len() < 20 {
+    error!("Cookie header is too short (len: {}): {}", cookie_header.len(), cookie_header);
+    return Err(MidjourneyClientError::CookieTooShort.into());
+  }
+
+  // NB: missing headers that were in the browser request:
+  // -H 'sec-ch-ua-platform: "macOS"' \
+  // -H 'sec-ch-ua: "Not)A;Brand";v="8", "Chromium";v="138", "Google Chrome";v="138"' \
+
+  let mut http_request = client.get(url)
+      .header("cookie", cookie_header)
+      .header("Referer", &referer)
+      .header("Referrer-Policy", "origin-when-cross-origin")
+      .header("accept", "*/*")
+      .header("accept-language", "en-US,en;q=0.8")
+      .header("content-type", "application/json")
+      .header("priority", "u=1, i")
+      .header("sec-ch-ua-mobile", "?0")
+      .header("sec-fetch-dest", "empty")
+      .header("sec-fetch-mode", "cors")
+      .header("sec-fetch-site", "same-origin")
+      .header("x-csrf-protection", "1");
+
+  let http_request  = http_request
+      .build()
+      .map_err(|err| MidjourneyClientError::WreqError(err))?;
+
+  let response = client.execute(http_request)
+      .await
+      .map_err(|e| MidjourneyApiError::NetworkError(e.to_string()))?;
+
+  let status = response.status();
+
+  // if status == 301 {
+  //   for (name, value) in response.headers().iter() {
+  //     println!("- {}: {}", name.as_str(), value.to_str().unwrap());
+  //   }
+  // }
+
+  let response_body = &response.text().await
+      .map_err(|e| MidjourneyApiError::NetworkError(e.to_string()))?;
+
+  if !status.is_success() {
+    if let Err(err) = filter_cloudflare_errors(status.as_u16(), &response_body) {
+      return Err(MidjourneyApiError::CloudflareError(err).into());
+    }
+  }
+
+  /*
+  [
+      {
+          "providerId": "google.com",
+          "userData": {
+              "providerId": "google.com",
+              "displayName": "John Doe",
+              "email": "john.doe@gmail.com",
+              "userId": "123456789000000001",
+          },
+          "isLinked": true
+      },
+      {
+          "providerId": "discord.com",
+          "isLinked": false
+      }
+  ]
+  */
+
+  #[derive(Deserialize, Debug)]
+  #[allow(non_snake_case)]
+  struct RawProviderUserData {
+    providerId: String,
+    displayName: Option<String>,
+    email: Option<String>,
+    userId: Option<String>,
+  }
+
+  #[derive(Deserialize, Debug)]
+  #[allow(non_snake_case)]
+  struct RawProvider {
+    providerId: String,
+    userData: Option<RawProviderUserData>,
+    isLinked: bool,
+  }
+
+  let response : Vec<RawProvider> = serde_json::from_str(response_body)
+      .map_err(|err| MidjourneyApiError::DeserializationError(err))?;
+
+  let providers = response
+      .into_iter()
+      .map(|r| Provider {
+        provider_id: r.providerId,
+        user_data: r.userData.map(|u| UserData {
+          provider_id: u.providerId,
+          display_name: u.displayName,
+          email: u.email,
+          user_id: u.userId,
+        }),
+        is_linked: r.isLinked,
+      })
+      .collect::<Vec<_>>();
+
+  Ok(providers)
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::client::midjourney_hostname::MidjourneyHostname;
+  use crate::endpoints::user_connections::{user_connections, GetUserConnectionsRequest};
+  use errors::AnyhowResult;
+  use filesys::read_to_trimmed_string::read_to_trimmed_string;
+
+  #[ignore]
+  #[tokio::test]
+  async fn test() -> AnyhowResult<()> {
+    let cookie_header = read_to_trimmed_string("/Users/bt/secrets/midjourney/cookie.txt")?;
+
+    let result = user_connections(GetUserConnectionsRequest {
+      cookie_header,
+      hostname: MidjourneyHostname::Standard,
+    }).await?;
+
+    println!("Response: {:?}\n\n", result);
+
+    for provider in result {
+      println!("Provider: {:?}", provider);
+    }
+
+    assert_eq!(1, 2);
+
+    Ok(())
+  }
+}
+

crates/api_clients/midjourney_client/src/error/midjourney_api_error.rs

@@ -0,0 +1,117 @@
+use cloudflare_errors::cloudflare_error::CloudflareError;
+use errors::AnyhowError;
+use std::error::Error;
+use std::fmt::{Display, Formatter};
+use std::io;
+
+#[derive(Debug)]
+pub enum MidjourneyApiError {
+  /// There was no user ID in an otherwise valid-looking response.
+  NoUserId,
+
+  /// No user props in index HTML payload.
+  /// We need this for the user ID and the websocket token.
+  NoUserProps,
+
+  /// No initialAuthUser in the index HTML payload.
+  /// We need this for the user ID and the websocket token.
+  NoInitialAuthUser,
+
+  /// 400. The request was invalid.
+  InvalidRequest(String),
+
+  /// 401. The request was not authorized.
+  Unauthorized(String),
+
+  /// 403. The request was forbidden.
+  Forbidden(String),
+
+  /// 404. The requested resource was not found.
+  NotFound(String),
+
+  /// 429. Too many requests.
+  TooManyRequests(String),
+
+  /// 500. An internal server error occurred.
+  InternalServerError {
+    body: String,
+    backend_hostname: Option<String>,
+  },
+
+  /// Eg. when downloading images
+  UnknownHttpFailure {
+    status_code: u16,
+    body: String,
+  },
+
+  /// Cloudflare errors.
+  CloudflareError(CloudflareError),
+
+  /// A deserialization error with the response.
+  DeserializationError(serde_json::Error),
+
+  /// The request timed out.
+  Timeout(String),
+
+  /// A network error occurred.
+  NetworkError(String),
+
+  /// An error doing file I/O (on our side)
+  IoError(io::Error),
+
+  /// Another type of error.
+  Other(AnyhowError),
+}
+
+impl Error for MidjourneyApiError {}
+
+impl Display for MidjourneyApiError {
+  fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    match self {
+      // Response body errors
+      Self::NoUserId => write!(f, "No user ID found in the response body."),
+      Self::NoUserProps => write!(f, "No user properties found in the index HTML payload."),
+      Self::NoInitialAuthUser => write!(f, "No initialAuthUser in the index HTML payload."),
+      // Server response code errors
+      Self::InvalidRequest(msg) => write!(f, "Invalid request: {}", msg),
+      Self::Unauthorized(msg) => write!(f, "Unauthorized: {}", msg),
+      Self::Forbidden(msg) => write!(f, "Forbidden: {}", msg),
+      Self::NotFound(msg) => write!(f, "Not found: {}", msg),
+      Self::TooManyRequests(msg) => write!(f, "Too many requests: {}", msg),
+      Self::InternalServerError {body, backend_hostname} =>
+        write!(f, "Internal Server Error; backend hostname: {:?} ; body: {}; ", backend_hostname, body),
+      Self::UnknownHttpFailure {status_code, body} =>
+        write!(f, "Unknown HTTP failure; status code: {}; body: {}", status_code, body),
+      // Deserialization errors
+      // Server response handling errors
+      Self::DeserializationError(error) => write!(f, "Deserialization error: {}", error),
+      // Network errors
+      Self::Timeout(msg) => write!(f, "Timeout: {}", msg),
+      Self::NetworkError(msg) => write!(f, "Network error: {}", msg),
+      // Cloudflare errors
+      Self::CloudflareError(error) => write!(f, "Cloudflare Error: {}", error),
+      // I/O errors
+      Self::IoError(error) => write!(f, "IO error: {}", error),
+      // Other
+      Self::Other(error) => write!(f, "Other error: {}", error),
+    }
+  }
+}
+
+impl From<serde_json::Error> for MidjourneyApiError {
+  fn from(error: serde_json::Error) -> Self {
+    Self::DeserializationError(error)
+  }
+}
+
+impl From<io::Error> for MidjourneyApiError {
+  fn from(error: io::Error) -> Self {
+    Self::IoError(error)
+  }
+}
+
+impl From<CloudflareError> for MidjourneyApiError {
+  fn from(error: CloudflareError) -> Self {
+    Self::CloudflareError(error)
+  }
+}

crates/api_clients/midjourney_client/src/error/midjourney_client_error.rs

@@ -0,0 +1,71 @@
+use std::error::Error;
+use std::fmt::{Display, Formatter};
+use std::io;
+use std::path::PathBuf;
+
+/// An error arising from the client, either before or after the request is sent.
+#[derive(Debug)]
+pub enum MidjourneyClientError {
+  /// The cookie was too short to be valid.
+  CookieTooShort,
+  
+  /// Tried to look up an image out of range [0,4)
+  InvalidImageIndex,
+  
+  /// Could not determine the filetype for the file.
+  FileTypeNotKnown(PathBuf),
+
+  /// Could not handle the file type.
+  FileTypeNotHandled(PathBuf),
+
+  /// An error doing file I/O (on our side)
+  IoError(io::Error),
+
+  // /// An error setting up the client
+  // ReqwestError(reqwest::Error),
+  WreqError(wreq::Error),
+
+  /// A serialization error with the request.
+  SerializationError(serde_json::Error),
+}
+
+impl Error for MidjourneyClientError {}
+
+impl Display for MidjourneyClientError {
+  fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    match self {
+      Self::CookieTooShort => write!(f, "The cookie header is too short to be valid."),
+      Self::InvalidImageIndex => write!(f, "The image index is out of range. Valid range is [0, 4)."),
+      Self::FileTypeNotKnown(path) => write!(f, "Could not determine the filetype for the file: {:?}", path),
+      Self::FileTypeNotHandled(path) => write!(f, "Could not handle the file type for the file: {:?}", path),
+      Self::IoError(err) => write!(f, "IO error: {}", err),
+      //Self::ReqwestError(err) => write!(f, "Reqwest client error: {}", err),
+      Self::WreqError(err) => write!(f, "Wreq client error: {}", err),
+      Self::SerializationError(err) => write!(f, "Request serialization error: {}", err),
+    }
+  }
+}
+
+impl From<io::Error> for MidjourneyClientError {
+  fn from(error: io::Error) -> Self {
+    Self::IoError(error)
+  }
+}
+
+impl From<serde_json::Error> for MidjourneyClientError {
+  fn from(error: serde_json::Error) -> Self {
+    Self::SerializationError(error)
+  }
+}
+
+/*impl From<reqwest::Error> for MidjourneyClientError {
+  fn from(error: reqwest::Error) -> Self {
+    Self::ReqwestError(error)
+  }
+}*/
+
+impl From<wreq::Error> for MidjourneyClientError {
+  fn from(error: wreq::Error) -> Self {
+    Self::WreqError(error)
+  }
+}

crates/api_clients/midjourney_client/src/error/midjourney_error.rs

@@ -0,0 +1,32 @@
+use crate::error::midjourney_api_error::MidjourneyApiError;
+use crate::error::midjourney_client_error::MidjourneyClientError;
+use std::error::Error;
+
+#[derive(Debug)]
+pub enum MidjourneyError {
+  Api(MidjourneyApiError),
+  Client(MidjourneyClientError),
+}
+
+impl Error for MidjourneyError {}
+
+impl std::fmt::Display for MidjourneyError {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    match self {
+      Self::Api(e) => write!(f, "Midjourney API error: {:?}", e),
+      Self::Client(e) => write!(f, "Midjourney Client error: {:?}", e),
+    }
+  }
+}
+
+impl From<MidjourneyApiError> for MidjourneyError {
+  fn from(error: MidjourneyApiError) -> Self {
+    Self::Api(error)
+  }
+}
+
+impl From<MidjourneyClientError> for MidjourneyError {
+  fn from(error: MidjourneyClientError) -> Self {
+    Self::Client(error)
+  }
+}

crates/api_clients/midjourney_client/src/error/mod.rs

@@ -0,0 +1,3 @@
+pub mod midjourney_error;
+pub mod midjourney_api_error;
+pub mod midjourney_client_error;

crates/api_clients/midjourney_client/src/lib.rs

@@ -0,0 +1,8 @@
+//! A midjourney API client.
+
+pub mod client;
+pub mod credentials;
+pub mod endpoints;
+pub mod error;
+pub mod recipes;
+pub mod utils;

crates/api_clients/midjourney_client/src/recipes/channel_id.rs

@@ -0,0 +1,20 @@
+use crate::credentials::midjourney_user_id::MidjourneyUserId;
+
+#[derive(Debug, Clone)]
+pub enum ChannelId {
+  /// Channel based on the user ID.
+  /// This is what Midjourney uses by default.
+  UserId(MidjourneyUserId),
+
+  // Bare string ID
+  Raw(String),
+}
+
+impl ChannelId {
+  pub fn to_string(&self) -> String {
+    match self {
+      Self::UserId(user_id) => format!("singleplayer_{}", user_id.0),
+      Self::Raw(id) => id.clone(),
+    }
+  }
+}

crates/api_clients/midjourney_client/src/recipes/get_midjourney_user_id_from_storage.rs

@@ -0,0 +1,52 @@
+use crate::client::midjourney_hostname::MidjourneyHostname;
+use crate::credentials::midjourney_user_id::MidjourneyUserId;
+use crate::endpoints::storage_list::{storage_list, GetStorageListRequest};
+use crate::error::midjourney_api_error::MidjourneyApiError;
+use crate::error::midjourney_error::MidjourneyError;
+
+pub struct GetMidjourneyUserIdRequest {
+  pub hostname: MidjourneyHostname,
+  pub cookie_header: String,
+}
+
+pub async fn get_midjourney_user_id_from_storage(req: GetMidjourneyUserIdRequest) -> Result<MidjourneyUserId, MidjourneyError> {
+  let items = storage_list(GetStorageListRequest {
+    hostname: req.hostname,
+    cookie_header: req.cookie_header,
+  }).await?;
+
+  let user_id = items
+    .into_iter()
+    .find_map(|item| item.bucket_pathname)
+    .and_then(|path| path.split('/').next().map(|id| id.to_owned()))
+    .map(|id| MidjourneyUserId(id.to_string()))
+    .ok_or(MidjourneyApiError::NoUserId)?;
+
+  Ok(user_id)
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::client::midjourney_hostname::MidjourneyHostname;
+  use crate::recipes::get_midjourney_user_id_from_storage::{get_midjourney_user_id_from_storage, GetMidjourneyUserIdRequest};
+  use errors::AnyhowResult;
+  use filesys::read_to_trimmed_string::read_to_trimmed_string;
+
+  #[ignore]
+  #[tokio::test]
+  async fn test() -> AnyhowResult<()> {
+    let cookie_header = read_to_trimmed_string("/Users/bt/secrets/midjourney/cookie.txt")?;
+
+    let result = get_midjourney_user_id_from_storage(GetMidjourneyUserIdRequest {
+      cookie_header,
+      hostname: MidjourneyHostname::Standard,
+    }).await?;
+
+    println!("Response: {:?}\n\n", result);
+
+    assert_eq!(1, 2);
+
+    Ok(())
+  }
+}
+

crates/api_clients/midjourney_client/src/recipes/get_user_info.rs

@@ -0,0 +1,153 @@
+use crate::client::midjourney_hostname::MidjourneyHostname;
+use crate::credentials::midjourney_user_id::MidjourneyUserId;
+use crate::endpoints::get_index_page_html::{get_index_page_html, GetIndexPageRequest};
+use crate::error::midjourney_api_error::MidjourneyApiError;
+use crate::error::midjourney_error::MidjourneyError;
+use dom_query::Document;
+use serde::Deserialize;
+
+pub struct GetUserInfoRequest {
+  pub hostname: MidjourneyHostname,
+  pub cookie_header: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct GetUserInfoResponse {
+  pub user_id: Option<MidjourneyUserId>,
+  pub email: Option<String>,
+  pub websocket_token: Option<String>,
+}
+
+pub async fn get_user_info(req: GetUserInfoRequest) -> Result<GetUserInfoResponse, MidjourneyError> {
+  let index_html = get_index_page_html(GetIndexPageRequest {
+    hostname: req.hostname,
+    cookie_header: req.cookie_header,
+  }).await?;
+
+  /*
+    <script id="initialProps" type="application/json">
+      {
+          "initialAuthUser": {
+              "idpID": "ENTROPY",
+              "id": "UUID",
+              "displayName": "uNUMBER",
+              "email": "USER@gmail.com",
+              "emailVerified": true,
+              "photoURL": "https://lh3.googleusercontent.com/a/ENTROPY",
+              "abilities": {
+                  "admin": false,
+                  "developer": false,
+                  "accepted_tos": true,
+                  "moderator": false,
+                  "guide": false,
+                  "vip": false,
+                  "employee": false,
+                  "content_moderator": false,
+                  "gdpr_preferences_set": false,
+                  "gdpr_allow_advertising": false,
+                  "gdpr_allow_analytics": false,
+                  "editor_whitelist": false,
+                  "allow_nsfw": false,
+                  "cooldowns_removed": false,
+                  "blocked": false,
+                  "community": false,
+                  "billing": false,
+                  "system_verified": false,
+                  "simplified_flow": false,
+                  "total_jobs": 57,
+                  "is_sub_at_least_one_year_old": false,
+                  "can_private": false,
+                  "can_relax": false,
+                  "has_discord": false,
+                  "delete_at": null,
+                  "subscription": {
+                      "type": "subscription",
+                      "plan_type": "basic",
+                      "recurring": "month"
+                  },
+                  "relax_video_job_concurrency": 0
+              },
+              "websocketToken": "WEBSOCKET_TOKEN_ENTROPY",
+              "providers": [
+                  "google.com"
+              ],
+              "system": "firebase",
+              "streamToken": "STREAM_TOKEN_ENTROPY"
+          },
+          "urlFromInitialServerRequest": "/"
+      }
+    </script>
+   */
+  
+  let document = Document::from(index_html);
+  let maybe_nodes = document.select("script[id=initialProps]");
+
+  let node = match maybe_nodes.get(0) {
+    Some(node) => node,
+    None => {
+      return Err(MidjourneyApiError::NoUserProps.into());
+    }
+  };
+
+  let inner_json = node.inner_html().to_string();
+
+  #[derive(Deserialize, Debug)]
+  #[allow(non_snake_case)]
+  struct RawAuthUser {
+    // NB: The Midjourney user id.
+    id: Option<String>,
+    email: Option<String>,
+    websocketToken: Option<String>,
+  }
+
+  #[derive(Deserialize, Debug)]
+  #[allow(non_snake_case)]
+  struct RawBody {
+    initialAuthUser: Option<RawAuthUser>,
+  }
+
+  let response : RawBody = serde_json::from_str(&inner_json)
+      .map_err(|err| MidjourneyApiError::DeserializationError(err))?;
+  
+  let props = match response.initialAuthUser {
+    Some(props) => props,
+    None => {
+      return Err(MidjourneyApiError::NoInitialAuthUser.into());
+    }
+  };
+
+  Ok(GetUserInfoResponse {
+    user_id: props.id
+        .map(|id| MidjourneyUserId::from_string(id)),
+    email: props.email
+        .map(|email| email.to_string()),
+    websocket_token: props.websocketToken
+        .map(|email| email.to_string()),
+  })
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::client::midjourney_hostname::MidjourneyHostname;
+  use crate::recipes::get_user_info::{get_user_info, GetUserInfoRequest};
+  use errors::AnyhowResult;
+  use filesys::read_to_trimmed_string::read_to_trimmed_string;
+
+  #[ignore]
+  #[tokio::test]
+  async fn test() -> AnyhowResult<()> {
+    let cookie_header = read_to_trimmed_string("/Users/bt/secrets/midjourney/cookie.txt")?;
+
+    let result = get_user_info(GetUserInfoRequest {
+      cookie_header,
+      hostname: MidjourneyHostname::Standard,
+    }).await?;
+
+    println!("Response: {:?}\n\n", result);
+
+    assert_eq!(1, 2);
+
+    Ok(())
+  }
+}
+

crates/api_clients/midjourney_client/src/recipes/mod.rs

@@ -0,0 +1,4 @@
+mod get_midjourney_user_id_from_storage;
+pub mod channel_id;
+pub mod get_user_info;
+pub mod text_to_image;

crates/api_clients/midjourney_client/src/recipes/text_to_image.rs

@@ -0,0 +1,49 @@
+use crate::client::midjourney_hostname::MidjourneyHostname;
+use crate::endpoints::submit_job::{submit_job, SubmitJobRequest};
+use crate::error::midjourney_error::MidjourneyError;
+use crate::recipes::channel_id::ChannelId;
+
+pub struct TextToImageRequest<'a> {
+  pub prompt: &'a str,
+  pub channel_id: &'a ChannelId,
+  pub hostname: MidjourneyHostname,
+  pub cookie_header: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct TextToImageResponse {
+  /// On success, the job ID is returned.
+  pub maybe_job_id: Option<String>,
+
+  /// On error, we have a list of error messages.
+  pub maybe_errors: Option<Vec<TextToImageError>>,
+}
+
+#[derive(Debug, Clone)]
+pub struct TextToImageError {
+  pub error_type: Option<String>,
+  pub message: Option<String>,
+}
+
+/// Slightly more ergonomic text-to-image API.
+/// As we add more `submit_job()` cases, we'll keep this simple.
+pub async fn text_to_image(req: TextToImageRequest<'_>) -> Result<TextToImageResponse, MidjourneyError> {
+  let channel_id = req.channel_id.to_string();
+
+  let response = submit_job(SubmitJobRequest {
+    prompt: req.prompt,
+    channel_id: &channel_id,
+    hostname: req.hostname,
+    cookie_header: req.cookie_header,
+  }).await?;
+
+  Ok(TextToImageResponse {
+    maybe_job_id: response.maybe_job_id,
+    maybe_errors: response.maybe_errors.map(|errs| {
+      errs.into_iter().map(|e| TextToImageError {
+        error_type: e.error_type,
+        message: e.message,
+      }).collect()
+    }),
+  })
+}

crates/api_clients/midjourney_client/src/utils/get_image_url.rs

@@ -0,0 +1,9 @@
+use crate::error::midjourney_client_error::MidjourneyClientError;
+use crate::error::midjourney_error::MidjourneyError;
+
+pub fn get_image_url(job_id: &str, image_index: u8) -> Result<String, MidjourneyError> {
+  if image_index > 3 {
+    return Err(MidjourneyClientError::InvalidImageIndex.into())
+  }
+  Ok(format!("https://cdn.midjourney.com/{}/0_{}.png", job_id, image_index))
+}

crates/api_clients/midjourney_client/src/utils/image_downloader_client.rs

@@ -0,0 +1,70 @@
+use crate::error::midjourney_api_error::MidjourneyApiError;
+use crate::error::midjourney_client_error::MidjourneyClientError;
+use crate::error::midjourney_error::MidjourneyError;
+use crate::utils::get_image_url::get_image_url;
+use cloudflare_errors::filter_cloudflare_errors::filter_cloudflare_errors;
+use wreq::Client;
+use wreq_util::Emulation;
+
+#[derive(Clone)]
+pub struct ImageDownloaderClient {
+  client: Client,
+}
+
+impl ImageDownloaderClient {
+  pub fn create() -> Result<Self, MidjourneyClientError> {
+    Ok(Self {
+      client: Client::builder()
+          .emulation(Emulation::Firefox139)
+          .build()
+          .map_err(|err| MidjourneyClientError::WreqError(err))?
+    })
+  }
+
+  pub async fn download_image(&self, job_id: &str, image_index: u8) -> anyhow::Result<Vec<u8>, MidjourneyError> {
+    let url = get_image_url(job_id, image_index)?;
+
+    // TODO: Cookies
+    // TODO: Cache control headers?
+    let mut http_request = self.client.get(url)
+        //.header("Referrer-Policy", "origin-when-cross-origin")
+        //.header("content-type", "application/json")
+        //.header("sec-fetch-user", "?1")
+        //.header("upgrade-insecure-requests", "1");
+        .header("Referrer", "https://www.midjourney.com/")
+        .header("accept", "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8")
+        .header("accept-language", "en-US,en;q=0.8")
+        .header("priority", "i")
+        .header("sec-ch-ua-mobile", "?0")
+        .header("sec-fetch-dest", "image")
+        .header("sec-fetch-mode", "no-cors")
+        .header("sec-fetch-site", "same-site");
+
+    let http_request  = http_request
+        .build()
+        .map_err(|err| MidjourneyClientError::WreqError(err))?;
+
+    let response = self.client.execute(http_request)
+        .await
+        .map_err(|e| MidjourneyApiError::NetworkError(e.to_string()))?;
+
+    let status = response.status();
+
+    let response_bytes = response.bytes().await
+        .map_err(|e| MidjourneyApiError::NetworkError(e.to_string()))?;
+
+    if !status.is_success() {
+      let response_body = String::from_utf8_lossy(&response_bytes).to_string();
+      if let Err(err) = filter_cloudflare_errors(status.as_u16(), &response_body) {
+        return Err(MidjourneyApiError::CloudflareError(err).into());
+      }
+
+      return Err(MidjourneyApiError::UnknownHttpFailure {
+        status_code: status.as_u16(),
+        body: response_body,
+      }.into());
+    }
+
+    Ok(response_bytes.to_vec())
+  }
+}

crates/api_clients/midjourney_client/src/utils/mod.rs

@@ -0,0 +1,2 @@
+pub mod get_image_url;
+pub mod image_downloader_client;

crates/api_clients/storyteller_client/src/error/api_error.rs

@@ -59,7 +59,7 @@ impl Display for ApiError {
       ApiError::Unauthorized(msg) => write!(f, "Unauthorized: {}", msg),
       ApiError::Forbidden(msg) => write!(f, "Forbidden: {}", msg),
       ApiError::NotFound(msg) => write!(f, "Not found: {}", msg),
-      ApiError::TooManyRequests(msg) => write!(f, "Too many requests: {}", msg),
+      ApiError::TooManyRequests(msg) => write!(f, "Too many requests to Storyteller backend: {}", msg),
       ApiError::InternalServerError {body, backend_hostname} => 
         write!(f, "Internal Server Error; backend hostname: {:?} ; body: {}; ", backend_hostname, body),
       // Server response handling errors

crates/api_clients/storyteller_client/src/error/client_error.rs

@@ -7,6 +7,9 @@ use crate::error::api_error::ApiError;
 /// An error arising from the client, either before or after the request is sent.
 #[derive(Debug)]
 pub enum ClientError {
+  /// An invalid request was detected before it was sent.
+  InvalidPreflightRequest(String),
+  
   /// Could not determine the filetype for the file.
   FileTypeNotKnown(PathBuf),
 
@@ -28,6 +31,7 @@ impl Error for ClientError {}
 impl Display for ClientError {
   fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
     match self {
+      Self::InvalidPreflightRequest(msg) => write!(f, "Invalid preflight request: {}", msg),
       Self::FileTypeNotKnown(path) => write!(f, "Could not determine the filetype for the file: {:?}", path),
       Self::FileTypeNotHandled(path) => write!(f, "Could not handle the file type for the file: {:?}", path),
       Self::IoError(err) => write!(f, "IO error: {}", err),

crates/api_clients/storyteller_client/src/error/storyteller_error.rs

@@ -13,8 +13,8 @@ impl Error for StorytellerError {}
 impl std::fmt::Display for StorytellerError {
   fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     match self {
-      StorytellerError::Api(e) => write!(f, "API error: {:?}", e),
-      StorytellerError::Client(e) => write!(f, "Client error: {:?}", e),
+      StorytellerError::Api(e) => write!(f, "Storyteller API error: {:?}", e),
+      StorytellerError::Client(e) => write!(f, "Storyteller Client error: {:?}", e),
     }
   }
 }

crates/api_clients/storyteller_client/src/lib.rs

@@ -5,6 +5,7 @@ pub mod error;
 pub mod generate;
 pub mod jobs;
 pub mod media_files;
+pub mod prompts;
 pub mod recipes;
 pub mod shared_response_types;
 pub mod utils;

crates/api_clients/storyteller_client/src/media_files/upload_image_media_file_from_file.rs

@@ -16,6 +16,7 @@ use enums::by_table::media_files::media_file_class::MediaFileClass;
 use enums::by_table::media_files::media_file_engine_category::MediaFileEngineCategory;
 use enums::by_table::media_files::media_file_type::MediaFileType;
 use enums::by_table::model_weights::weights_category::WeightsCategory;
+use enums::common::generation_provider::GenerationProvider;
 use enums::common::visibility::Visibility;
 use enums::no_table::style_transfer::style_transfer_name::StyleTransferName;
 use enums_public::by_table::model_weights::public_weights_types::PublicWeightsType;
@@ -42,6 +43,14 @@ pub struct UploadImageFromFileArgs<'a, P: AsRef<Path>> {
 
   /// If true, we should hide the image from the user's gallery.
   pub is_intermediate_system_file: bool,
+
+  /// If provided, this is the prompt that this image is associated with.
+  /// NOTE: Cannot set `is_intermediate_system_file = true` if this is set.
+  pub maybe_prompt_token: Option<&'a PromptToken>,
+
+  // /// If provided, this is the service provider that created the image.
+  // /// NOTE: Cannot set `is_intermediate_system_file = true` if this is set.
+  // pub maybe_generation_provider: Option<GenerationProvider>,
 }
 
 
@@ -49,6 +58,8 @@ pub struct UploadImageFromFileArgs<'a, P: AsRef<Path>> {
 pub async fn upload_image_media_file_from_file<P: AsRef<Path>>(
   args: UploadImageFromFileArgs<'_, P>,
 ) -> Result<UploadImageMediaFileSuccessResponse, StorytellerError> {
+  
+  validate_args(&args)?;
 
   let url = get_route(args.api_host);
 
@@ -70,6 +81,10 @@ pub async fn upload_image_media_file_from_file<P: AsRef<Path>>(
   if args.is_intermediate_system_file {
     form = form.text("is_intermediate_system_file", "true");
   }
+  
+  if let Some(prompt_token) = &args.maybe_prompt_token {
+    form = form.text("maybe_prompt_token", prompt_token.to_string());
+  }
 
   let mut request_builder = client.post(url)
       .header("User-Agent", USER_AGENT)
@@ -109,3 +124,15 @@ pub struct UploadImageMediaFileSuccessResponse {
   pub success: bool,
   pub media_file_token: MediaFileToken,
 }
+
+fn validate_args<P: AsRef<Path>>(
+  args: &UploadImageFromFileArgs<'_, P>,
+) -> Result<(), StorytellerError> {
+  if args.is_intermediate_system_file && args.maybe_prompt_token.is_some() {
+    return Err(StorytellerError::Client(ClientError::InvalidPreflightRequest(
+      "Cannot set `is_intermediate_system_file` to true if `maybe_prompt_token` is provided."
+          .to_string())));
+  }
+
+  Ok(())
+}

crates/api_clients/storyteller_client/src/prompts/create_prompt.rs

@@ -0,0 +1,18 @@
+use crate::credentials::storyteller_credential_set::StorytellerCredentialSet;
+use crate::error::storyteller_error::StorytellerError;
+use crate::utils::api_host::ApiHost;
+use crate::utils::basic_json_post_request::basic_json_post_request;
+use artcraft_api_defs::prompts::create_prompt::{CreatePromptRequest, CreatePromptResponse, CREATE_PROMPT_PATH};
+
+pub async fn create_prompt(
+  api_host: &ApiHost,
+  maybe_creds: Option<&StorytellerCredentialSet>,
+  request: CreatePromptRequest,
+) -> Result<CreatePromptResponse, StorytellerError> {
+  Ok(basic_json_post_request(
+    api_host,
+    CREATE_PROMPT_PATH,
+    maybe_creds,
+    request,
+  ).await?)
+}

crates/api_clients/storyteller_client/src/prompts/mod.rs

@@ -0,0 +1 @@
+pub mod create_prompt;

crates/api_clients/storyteller_client/src/recipes/upload_media_file_from_file.rs

@@ -10,6 +10,7 @@ use mimetypes::mimetype_info::mimetype_info::MimetypeInfo;
 use serde_derive::Deserialize;
 use std::path::Path;
 use tokens::tokens::media_files::MediaFileToken;
+use tokens::tokens::prompts::PromptToken;
 
 #[derive(Deserialize, Debug)]
 pub struct UploadMediaFileSuccessResponse {
@@ -22,6 +23,7 @@ pub async fn upload_media_file_from_file<P: AsRef<Path>>(
   api_host: &ApiHost,
   maybe_creds: Option<&StorytellerCredentialSet>,
   path: P,
+  maybe_prompt_token: Option<&PromptToken>,
 ) -> Result<UploadMediaFileSuccessResponse, StorytellerError> {
   
   let maybe_type = MimetypeInfo::get_for_path(path.as_ref())
@@ -54,6 +56,7 @@ pub async fn upload_media_file_from_file<P: AsRef<Path>>(
         maybe_creds,
         path,
         is_intermediate_system_file: false,
+        maybe_prompt_token,
       }).await;
       match result {
         Ok(result) => Ok(UploadMediaFileSuccessResponse {

crates/desktop/artcraft/Cargo.toml

@@ -23,25 +23,27 @@ tauri-build = { version = "2.1.1", features = [] }
 
 [dependencies]
 # Workspace hack (faster compile times)
-workspace-build-acceleration = { workspace =  true }
+workspace-build-acceleration.workspace =  true
 
 # Internal
-artcraft_api_defs = { workspace = true }
-build_metadata = { workspace = true }
-enums = { workspace = true }
-errors = { workspace = true }
-fal_client = { workspace = true }
-filesys = { workspace = true }
-idempotency = { workspace = true }
-images = { workspace = true }
-memory_store = { workspace = true }
-mimetypes = { workspace = true }
-openai_sora_client = { workspace = true }
-primitives = { workspace = true }
+artcraft_api_defs.workspace = true
+build_metadata.workspace = true
+cookie_store.workspace = true
+enums.workspace = true
+errors.workspace = true
+fal_client.workspace = true
+filesys.workspace = true
+idempotency.workspace = true
+images.workspace = true
+memory_store.workspace = true
+midjourney_client.workspace = true
+mimetypes.workspace = true
+openai_sora_client.workspace = true
+primitives.workspace = true
 sqlite_tasks.workspace = true
-storyteller_client = { workspace = true }
-tokens = { workspace = true }
-web_base64 = { workspace = true }
+storyteller_client.workspace = true
+tokens.workspace = true
+web_base64.workspace = true
 
 # External
 anyhow = { workspace = true }

crates/desktop/artcraft/capabilities/default.json

@@ -2,12 +2,13 @@
   "$schema": "../gen/schemas/desktop-schema.json",
   "identifier": "default",
   "description": "enables the default permissions",
-  "windows": [
-    "main"
-  ],
+  "windows": ["main"],
   "permissions": [
     "core:default",
     "log:default",
+    "core:window:allow-minimize",
+    "core:window:allow-toggle-maximize",
+    "core:window:allow-close",
     "upload:allow-download",
     "upload:default",
     "http:allow-fetch",
@@ -24,4 +25,4 @@
     },
     "dialog:default"
   ]
-}
+}

crates/desktop/artcraft/src/core/commands/enqueue/image_bg_removal/enqueue_image_bg_removal_command.rs

@@ -1,5 +1,3 @@
-use crate::core::commands::enqueue::image::enqueue_text_to_image_command::{EnqueueTextToImageRequest, EnqueueTextToImageSuccessResponse};
-use crate::core::commands::enqueue::image::internal_image_error::InternalImageError;
 use crate::core::commands::enqueue::image_bg_removal::errors::InternalBgRemovalError;
 use crate::core::commands::enqueue::image_bg_removal::generic::handle_generic_bg_removal::handle_generic_bg_removal;
 use crate::core::commands::enqueue::image_edit::errors::InternalContextualEditImageError;
@@ -29,6 +27,7 @@ use crate::services::sora::state::sora_task_queue::SoraTaskQueue;
 use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
 use enums::tauri::tasks::task_status::TaskStatus;
 use enums::tauri::tasks::task_type::TaskType;
+use enums::tauri::ux::tauri_command_caller::TauriCommandCaller;
 use errors::AnyhowError;
 use log::{error, info, warn};
 use openai_sora_client::recipes::image_remix_with_session_auto_renew::{image_remix_with_session_auto_renew, ImageRemixAutoRenewRequest};
@@ -43,7 +42,6 @@ use storyteller_client::error::storyteller_error::StorytellerError;
 use storyteller_client::media_files::get_media_file::get_media_file;
 use storyteller_client::utils::api_host::ApiHost;
 use tauri::{AppHandle, Manager, State};
-use enums::tauri::ux::tauri_command_caller::TauriCommandCaller;
 use tokens::tokens::media_files::MediaFileToken;
 
 #[derive(Deserialize, Debug)]

crates/desktop/artcraft/src/core/commands/enqueue/image_bg_removal/generic/handle_generic_bg_removal_artcraft.rs

@@ -1,5 +1,3 @@
-use crate::core::commands::enqueue::image::enqueue_text_to_image_command::EnqueueTextToImageRequest;
-use crate::core::commands::enqueue::image::internal_image_error::InternalImageError;
 use crate::core::commands::enqueue::image_bg_removal::enqueue_image_bg_removal_command::EnqueueImageBgRemovalCommand;
 use crate::core::commands::enqueue::image_bg_removal::errors::InternalBgRemovalError;
 use crate::core::commands::enqueue::image_edit::enqueue_contextual_edit_image_command::{EditImageQuality, EditImageSize, EnqueueContextualEditImageCommand};
@@ -129,6 +127,7 @@ async fn upload_image_from_base64_bytes(
         maybe_creds: Some(&creds),
         path: temp_file,
         is_intermediate_system_file: true, // NB: Probably not essential to keep this.
+        maybe_prompt_token: None, // NB: Not used for bg removal.
       }).await
           .map_err(|err| {
             error!("Failed to upload image media file: {:?}", err);

crates/desktop/artcraft/src/core/commands/enqueue/image_edit/enqueue_contextual_edit_image_command.rs

@@ -1,6 +1,5 @@
-use crate::core::commands::enqueue::image::enqueue_text_to_image_command::{EnqueueTextToImageRequest, EnqueueTextToImageSuccessResponse};
-use crate::core::commands::enqueue::image::internal_image_error::InternalImageError;
 use crate::core::commands::enqueue::image_edit::errors::InternalContextualEditImageError;
+use crate::core::commands::enqueue::image_edit::flux_kontext::handle_flux_kontext_edit::handle_flux_kontext_edit;
 use crate::core::commands::enqueue::image_edit::gpt_image_1::handle_gpt_image_1_edit::handle_gpt_image_1_edit;
 use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
 use crate::core::commands::response::failure_response_wrapper::{CommandErrorResponseWrapper, CommandErrorStatus};
@@ -43,7 +42,6 @@ use storyteller_client::media_files::get_media_file::get_media_file;
 use storyteller_client::utils::api_host::ApiHost;
 use tauri::{AppHandle, Manager, State};
 use tokens::tokens::media_files::MediaFileToken;
-use crate::core::commands::enqueue::image_edit::flux_kontext::handle_flux_kontext_edit::handle_flux_kontext_edit;
 
 #[derive(Deserialize, Debug)]
 pub struct EnqueueContextualEditImageCommand {

crates/desktop/artcraft/src/core/commands/enqueue/image_edit/flux_kontext/handle_flux_kontext_edit_artcraft.rs

@@ -1,5 +1,3 @@
-use crate::core::commands::enqueue::image::enqueue_text_to_image_command::EnqueueTextToImageRequest;
-use crate::core::commands::enqueue::image::internal_image_error::InternalImageError;
 use crate::core::commands::enqueue::image_edit::enqueue_contextual_edit_image_command::{EditImageQuality, EditImageSize, EnqueueContextualEditImageCommand};
 use crate::core::commands::enqueue::image_edit::errors::InternalContextualEditImageError;
 use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;

crates/desktop/artcraft/src/core/commands/enqueue/image_edit/gpt_image_1/handle_gpt_image_1_edit_artcraft.rs

@@ -1,5 +1,3 @@
-use crate::core::commands::enqueue::image::enqueue_text_to_image_command::EnqueueTextToImageRequest;
-use crate::core::commands::enqueue::image::internal_image_error::InternalImageError;
 use crate::core::commands::enqueue::image_edit::enqueue_contextual_edit_image_command::{EditImageQuality, EditImageSize, EnqueueContextualEditImageCommand};
 use crate::core::commands::enqueue::image_edit::errors::InternalContextualEditImageError;
 use crate::core::commands::enqueue::image_edit::gpt_image_1::handle_gpt_image_1_edit::MAX_IMAGES;
@@ -23,6 +21,8 @@ use artcraft_api_defs::generate::image::generate_flux_1_dev_text_to_image::Gener
 use artcraft_api_defs::generate::image::generate_flux_1_schnell_text_to_image::GenerateFlux1SchnellTextToImageRequest;
 use artcraft_api_defs::generate::image::generate_flux_pro_11_text_to_image::GenerateFluxPro11TextToImageRequest;
 use artcraft_api_defs::generate::image::generate_flux_pro_11_ultra_text_to_image::GenerateFluxPro11UltraTextToImageRequest;
+use enums::common::generation_provider::GenerationProvider;
+use enums::tauri::tasks::task_type::TaskType;
 use fal_client::requests::queue::image_gen::enqueue_flux_pro_11_ultra_text_to_image::{enqueue_flux_pro_11_ultra_text_to_image, FluxPro11UltraTextToImageArgs};
 use fal_client::requests::webhook::image::enqueue_gpt_image_1_edit_image_webhook::GptEditImageQuality;
 use idempotency::uuid::generate_random_uuid;
@@ -33,8 +33,6 @@ use storyteller_client::generate::image::generate_flux_1_schnell_text_to_image::
 use storyteller_client::generate::image::generate_flux_pro_11_text_to_image::generate_flux_pro_11_text_to_image;
 use storyteller_client::generate::image::generate_flux_pro_11_ultra_text_to_image::generate_flux_pro_11_ultra_text_to_image;
 use tauri::AppHandle;
-use enums::common::generation_provider::GenerationProvider;
-use enums::tauri::tasks::task_type::TaskType;
 
 pub async fn handle_gpt_image_1_edit_artcraft(
   request: &EnqueueContextualEditImageCommand,

crates/desktop/artcraft/src/core/commands/enqueue/image_edit/gpt_image_1/handle_gpt_image_1_edit_sora.rs

@@ -1,11 +1,10 @@
-use crate::core::commands::enqueue::image::enqueue_text_to_image_command::EnqueueTextToImageRequest;
-use crate::core::commands::enqueue::image::internal_image_error::InternalImageError;
 use crate::core::commands::enqueue::image_edit::enqueue_contextual_edit_image_command::{EditImageSize, EnqueueContextualEditImageCommand, EnqueueContextualEditImageErrorType};
 use crate::core::commands::enqueue::image_edit::errors::InternalContextualEditImageError;
 use crate::core::commands::enqueue::image_edit::gpt_image_1::handle_gpt_image_1_edit::MAX_IMAGES;
 use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
 use crate::core::commands::response::failure_response_wrapper::{CommandErrorResponseWrapper, CommandErrorStatus};
 use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
+use crate::core::events::functional_events::show_provider_login_modal_event::ShowProviderLoginModalEvent;
 use crate::core::events::generation_events::common::{GenerationAction, GenerationModel, GenerationServiceProvider};
 use crate::core::events::generation_events::generation_enqueue_failure_event::GenerationEnqueueFailureEvent;
 use crate::core::events::generation_events::generation_enqueue_success_event::GenerationEnqueueSuccessEvent;
@@ -57,14 +56,16 @@ pub async fn handle_gpt_image_1_edit_sora(
   sora_task_queue: &SoraTaskQueue,
 ) -> Result<TaskEnqueueSuccess, InternalContextualEditImageError> {
 
-  let sora_creds = match sora_creds_manager.get_credentials() {
+  let mut creds = match sora_creds_manager.get_credentials() {
     Ok(Some(creds)) => creds,
     Ok(None) => {
       warn!("No Sora credentials found.");
+      ShowProviderLoginModalEvent::send_for_provider(GenerationProvider::Sora, &app);
       return Err(InternalContextualEditImageError::NeedsSoraCredentials);
     }
     Err(err) => {
       error!("Failed to get Sora credentials: {:?}", err);
+      ShowProviderLoginModalEvent::send_for_provider(GenerationProvider::Sora, &app);
       return Err(InternalContextualEditImageError::AnyhowError(err));
     }
   };
@@ -113,9 +114,6 @@ pub async fn handle_gpt_image_1_edit_sora(
     files_to_upload_to_sora.push(filename);
   }
 
-
-  let mut creds = sora_creds_manager.get_credentials_required()?;
-
   let credential_updated = maybe_upgrade_or_renew_session(&mut creds)
       .await
       .map_err(|err| {

crates/desktop/artcraft/src/core/commands/enqueue/image_inpaint/enqueue_image_inpaint_command.rs

@@ -1,5 +1,3 @@
-use crate::core::commands::enqueue::image::enqueue_text_to_image_command::{EnqueueTextToImageRequest, EnqueueTextToImageSuccessResponse};
-use crate::core::commands::enqueue::image::internal_image_error::InternalImageError;
 use crate::core::commands::enqueue::image_edit::errors::InternalContextualEditImageError;
 use crate::core::commands::enqueue::image_edit::gpt_image_1::handle_gpt_image_1_edit::handle_gpt_image_1_edit;
 use crate::core::commands::enqueue::image_inpaint::errors::InternalImageInpaintError;

crates/desktop/artcraft/src/core/commands/enqueue/image_inpaint/flux_pro_1_inpaint/handle_flux_pro_1_inpaint_artcraft.rs

@@ -1,5 +1,3 @@
-use crate::core::commands::enqueue::image::enqueue_text_to_image_command::EnqueueTextToImageRequest;
-use crate::core::commands::enqueue::image::internal_image_error::InternalImageError;
 use crate::core::commands::enqueue::image_bg_removal::enqueue_image_bg_removal_command::EnqueueImageBgRemovalCommand;
 use crate::core::commands::enqueue::image_bg_removal::errors::InternalBgRemovalError;
 use crate::core::commands::enqueue::image_edit::enqueue_contextual_edit_image_command::{EditImageQuality, EditImageSize, EnqueueContextualEditImageCommand};

crates/desktop/artcraft/src/core/commands/enqueue/image_to_object/enqueue_image_to_3d_object_command.rs

@@ -1,12 +1,15 @@
-use crate::core::commands::enqueue::object::generic::handle_object::handle_object;
-use crate::core::commands::enqueue::object::internal_object_error::InternalObjectError;
+use crate::core::commands::enqueue::image_to_object::generic::handle_object::handle_object;
+use crate::core::commands::enqueue::image_to_object::internal_object_error::InternalObjectError;
 use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
 use crate::core::commands::response::failure_response_wrapper::{CommandErrorResponseWrapper, CommandErrorStatus};
 use crate::core::commands::response::shorthand::Response;
 use crate::core::commands::response::success_response_wrapper::SerializeMarker;
+use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
+use crate::core::events::generation_events::generation_enqueue_success_event::GenerationEnqueueSuccessEvent;
 use crate::core::state::app_env_configs::app_env_configs::AppEnvConfigs;
 use crate::core::state::data_dir::app_data_root::AppDataRoot;
 use crate::core::state::provider_priority::{Provider, ProviderPriorityStore};
+use crate::core::state::task_database::TaskDatabase;
 use crate::services::fal::state::fal_credential_manager::FalCredentialManager;
 use crate::services::fal::state::fal_task_queue::FalTaskQueue;
 use crate::services::sora::state::sora_task_queue::SoraTaskQueue;
@@ -16,9 +19,6 @@ use log::{error, info, warn};
 use serde_derive::{Deserialize, Serialize};
 use tauri::{AppHandle, State};
 use tokens::tokens::media_files::MediaFileToken;
-use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
-use crate::core::events::generation_events::generation_enqueue_success_event::GenerationEnqueueSuccessEvent;
-use crate::core::state::task_database::TaskDatabase;
 
 #[derive(Deserialize)]
 pub struct EnqueueImageTo3dObjectRequest {

crates/desktop/artcraft/src/core/commands/enqueue/image_to_object/generic/handle_object.rs

@@ -1,7 +1,7 @@
-use crate::core::commands::enqueue::object::enqueue_image_to_3d_object_command::EnqueueImageTo3dObjectRequest;
-use crate::core::commands::enqueue::object::generic::handle_object_artcraft::handle_object_artcraft;
-use crate::core::commands::enqueue::object::generic::handle_object_fal::handle_object_fal;
-use crate::core::commands::enqueue::object::internal_object_error::InternalObjectError;
+use crate::core::commands::enqueue::image_to_object::enqueue_image_to_3d_object_command::EnqueueImageTo3dObjectRequest;
+use crate::core::commands::enqueue::image_to_object::generic::handle_object_artcraft::handle_object_artcraft;
+use crate::core::commands::enqueue::image_to_object::generic::handle_object_fal::handle_object_fal;
+use crate::core::commands::enqueue::image_to_object::internal_object_error::InternalObjectError;
 use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
 use crate::core::state::app_env_configs::app_env_configs::AppEnvConfigs;
 use crate::core::state::data_dir::app_data_root::AppDataRoot;

crates/desktop/artcraft/src/core/commands/enqueue/image_to_object/generic/handle_object_artcraft.rs

@@ -1,5 +1,5 @@
-use crate::core::commands::enqueue::object::enqueue_image_to_3d_object_command::{EnqueueImageTo3dObjectModel, EnqueueImageTo3dObjectRequest};
-use crate::core::commands::enqueue::object::internal_object_error::InternalObjectError;
+use crate::core::commands::enqueue::image_to_object::enqueue_image_to_3d_object_command::{EnqueueImageTo3dObjectModel, EnqueueImageTo3dObjectRequest};
+use crate::core::commands::enqueue::image_to_object::internal_object_error::InternalObjectError;
 use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
 use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
 use crate::core::events::generation_events::common::{GenerationAction, GenerationModel, GenerationServiceProvider};

crates/desktop/artcraft/src/core/commands/enqueue/image_to_object/generic/handle_object_fal.rs

@@ -1,5 +1,5 @@
-use crate::core::commands::enqueue::object::enqueue_image_to_3d_object_command::{EnqueueImageTo3dObjectModel, EnqueueImageTo3dObjectRequest};
-use crate::core::commands::enqueue::object::internal_object_error::InternalObjectError;
+use crate::core::commands::enqueue::image_to_object::enqueue_image_to_3d_object_command::{EnqueueImageTo3dObjectModel, EnqueueImageTo3dObjectRequest};
+use crate::core::commands::enqueue::image_to_object::internal_object_error::InternalObjectError;
 use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
 use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
 use crate::core::events::generation_events::common::{GenerationAction, GenerationModel, GenerationServiceProvider};

crates/desktop/artcraft/src/core/commands/enqueue/image_to_video/enqueue_image_to_video_command.rs

@@ -1,6 +1,6 @@
+use crate::core::commands::enqueue::image_to_video::generic::handle_video::handle_video;
+use crate::core::commands::enqueue::image_to_video::internal_video_error::InternalVideoError;
 use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
-use crate::core::commands::enqueue::video::generic::handle_video::handle_video;
-use crate::core::commands::enqueue::video::internal_video_error::InternalVideoError;
 use crate::core::commands::response::failure_response_wrapper::{CommandErrorResponseWrapper, CommandErrorStatus};
 use crate::core::commands::response::shorthand::Response;
 use crate::core::commands::response::success_response_wrapper::SerializeMarker;

crates/desktop/artcraft/src/core/commands/enqueue/image_to_video/generic/handle_video.rs

@@ -1,8 +1,8 @@
+use crate::core::commands::enqueue::image_to_video::enqueue_image_to_video_command::EnqueueImageToVideoRequest;
+use crate::core::commands::enqueue::image_to_video::generic::handle_video_artcraft::handle_video_artcraft;
+use crate::core::commands::enqueue::image_to_video::generic::handle_video_fal::handle_video_fal;
+use crate::core::commands::enqueue::image_to_video::internal_video_error::InternalVideoError;
 use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
-use crate::core::commands::enqueue::video::enqueue_image_to_video_command::EnqueueImageToVideoRequest;
-use crate::core::commands::enqueue::video::generic::handle_video_artcraft::handle_video_artcraft;
-use crate::core::commands::enqueue::video::generic::handle_video_fal::handle_video_fal;
-use crate::core::commands::enqueue::video::internal_video_error::InternalVideoError;
 use crate::core::state::app_env_configs::app_env_configs::AppEnvConfigs;
 use crate::core::state::data_dir::app_data_root::AppDataRoot;
 use crate::core::state::provider_priority::{Provider, ProviderPriorityStore};

crates/desktop/artcraft/src/core/commands/enqueue/image_to_video/generic/handle_video_artcraft.rs

@@ -1,6 +1,6 @@
+use crate::core::commands::enqueue::image_to_video::enqueue_image_to_video_command::EnqueueImageToVideoRequest;
+use crate::core::commands::enqueue::image_to_video::internal_video_error::InternalVideoError;
 use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
-use crate::core::commands::enqueue::video::enqueue_image_to_video_command::EnqueueImageToVideoRequest;
-use crate::core::commands::enqueue::video::internal_video_error::InternalVideoError;
 use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
 use crate::core::events::generation_events::common::{GenerationAction, GenerationModel, GenerationServiceProvider};
 use crate::core::events::generation_events::generation_enqueue_failure_event::GenerationEnqueueFailureEvent;

crates/desktop/artcraft/src/core/commands/enqueue/image_to_video/generic/handle_video_fal.rs

@@ -1,6 +1,6 @@
+use crate::core::commands::enqueue::image_to_video::enqueue_image_to_video_command::EnqueueImageToVideoRequest;
+use crate::core::commands::enqueue::image_to_video::internal_video_error::InternalVideoError;
 use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
-use crate::core::commands::enqueue::video::enqueue_image_to_video_command::EnqueueImageToVideoRequest;
-use crate::core::commands::enqueue::video::internal_video_error::InternalVideoError;
 use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
 use crate::core::events::generation_events::common::{GenerationAction, GenerationModel, GenerationServiceProvider};
 use crate::core::events::generation_events::generation_enqueue_failure_event::GenerationEnqueueFailureEvent;

crates/desktop/artcraft/src/core/commands/enqueue/mod.rs

@@ -1,7 +1,7 @@
-pub mod image;
 pub mod image_bg_removal;
 pub mod image_edit;
 pub mod image_inpaint;
-pub mod object;
+pub mod image_to_object;
+pub mod image_to_video;
 pub mod task_enqueue_success;
-pub mod video;
+pub mod text_to_image;

crates/desktop/artcraft/src/core/commands/enqueue/task_enqueue_success.rs

@@ -31,6 +31,7 @@ impl TaskEnqueueSuccess{
     match self.provider {
       GenerationProvider::Artcraft => GenerationServiceProvider::Artcraft,
       GenerationProvider::Fal => GenerationServiceProvider::Fal,
+      GenerationProvider::Midjourney => GenerationServiceProvider::Midjourney,
       GenerationProvider::Sora => GenerationServiceProvider::Sora,
     }
   }
@@ -69,6 +70,7 @@ impl TaskEnqueueSuccess{
       Some(GenerationModel::Veo2) => Some(TaskModelType::Veo2),
       Some(GenerationModel::Hunyuan3d2_0) => Some(TaskModelType::Hunyuan3d2_0),
       Some(GenerationModel::Hunyuan3d2_1) => Some(TaskModelType::Hunyuan3d2_1),
+      Some(GenerationModel::Midjourney) => Some(TaskModelType::Midjourney), // NB: This is a generic Midjourney model, version unknown.
 
       // TODO: These seem wrong -
       Some(GenerationModel::Kling1_6) => Some(TaskModelType::Kling16Pro), // NB: `VideoModel::Kling16Pro`.

crates/desktop/artcraft/src/core/commands/enqueue/text_to_image/enqueue_text_to_image_command.rs

@@ -1,9 +1,10 @@
-use crate::core::commands::enqueue::image::generic::handle_image_artcraft::handle_image_artcraft;
-use crate::core::commands::enqueue::image::generic::handle_image_fal::handle_image_fal;
-use crate::core::commands::enqueue::image::gpt_image_1::handle_gpt_image_1::handle_gpt_image_1;
-use crate::core::commands::enqueue::image::gpt_image_1::handle_gpt_image_1_sora::handle_gpt_image_1_sora;
-use crate::core::commands::enqueue::image::internal_image_error::InternalImageError;
 use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
+use crate::core::commands::enqueue::text_to_image::generic::handle_image_artcraft::handle_image_artcraft;
+use crate::core::commands::enqueue::text_to_image::generic::handle_image_fal::handle_image_fal;
+use crate::core::commands::enqueue::text_to_image::gpt_image_1::handle_gpt_image_1::handle_gpt_image_1;
+use crate::core::commands::enqueue::text_to_image::gpt_image_1::handle_gpt_image_1_sora::handle_gpt_image_1_sora;
+use crate::core::commands::enqueue::text_to_image::internal_image_error::InternalImageError;
+use crate::core::commands::enqueue::text_to_image::midjourney::handle_midjourney::handle_midjourney;
 use crate::core::commands::response::failure_response_wrapper::{CommandErrorResponseWrapper, CommandErrorStatus};
 use crate::core::commands::response::shorthand::Response;
 use crate::core::commands::response::success_response_wrapper::SerializeMarker;
@@ -18,6 +19,7 @@ use crate::core::state::provider_priority::{Provider, ProviderPriorityStore};
 use crate::core::state::task_database::TaskDatabase;
 use crate::services::fal::state::fal_credential_manager::FalCredentialManager;
 use crate::services::fal::state::fal_task_queue::FalTaskQueue;
+use crate::services::midjourney::state::midjourney_credential_manager::MidjourneyCredentialManager;
 use crate::services::sora::state::sora_credential_manager::SoraCredentialManager;
 use crate::services::sora::state::sora_task_queue::SoraTaskQueue;
 use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
@@ -93,6 +95,7 @@ pub async fn enqueue_text_to_image_command(
   provider_priority_store: State<'_, ProviderPriorityStore>,
   task_database: State<'_, TaskDatabase>,
   fal_creds_manager: State<'_, FalCredentialManager>,
+  mj_creds_manager: State<'_, MidjourneyCredentialManager>,
   storyteller_creds_manager: State<'_, StorytellerCredentialManager>,
   fal_task_queue: State<'_, FalTaskQueue>,
   sora_creds_manager: State<'_, SoraCredentialManager>,
@@ -108,6 +111,7 @@ pub async fn enqueue_text_to_image_command(
     &provider_priority_store,
     &task_database,
     &fal_creds_manager,
+    &mj_creds_manager,
     &storyteller_creds_manager,
     &app_env_configs,
     &fal_task_queue,
@@ -173,6 +177,7 @@ pub async fn handle_request(
   provider_priority_store: &ProviderPriorityStore,
   task_database: &TaskDatabase,
   fal_creds_manager: &FalCredentialManager,
+  mj_creds_manager: &MidjourneyCredentialManager,
   storyteller_creds_manager: &StorytellerCredentialManager,
   app_env_configs: &AppEnvConfigs,
   fal_task_queue: &FalTaskQueue,
@@ -189,6 +194,7 @@ pub async fn handle_request(
     &storyteller_creds_manager,
     &app_env_configs,
     &fal_task_queue,
+    &mj_creds_manager,
     &sora_creds_manager,
     &sora_task_queue,
   ).await;
@@ -219,6 +225,7 @@ pub async fn dispatch_request(
   storyteller_creds_manager: &StorytellerCredentialManager,
   app_env_configs: &AppEnvConfigs,
   fal_task_queue: &FalTaskQueue,
+  mj_creds_manager: &MidjourneyCredentialManager,
   sora_creds_manager: &SoraCredentialManager,
   sora_task_queue: &SoraTaskQueue,
 ) -> Result<TaskEnqueueSuccess, InternalImageError> {
@@ -239,6 +246,14 @@ pub async fn dispatch_request(
         sora_task_queue,
       ).await;
     }
+    Some(ImageModel::Midjourney) => {
+      return handle_midjourney(
+        app,
+        request,
+        app_env_configs,
+        mj_creds_manager,
+      ).await;
+    }
     _ => {
       // Fall-through
     }

crates/desktop/artcraft/src/core/commands/enqueue/text_to_image/generic/handle_image_artcraft.rs

@@ -1,6 +1,6 @@
-use crate::core::commands::enqueue::image::enqueue_text_to_image_command::{EnqueueTextToImageRequest, TextToImageSize};
-use crate::core::commands::enqueue::image::internal_image_error::InternalImageError;
 use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
+use crate::core::commands::enqueue::text_to_image::enqueue_text_to_image_command::{EnqueueTextToImageRequest, TextToImageSize};
+use crate::core::commands::enqueue::text_to_image::internal_image_error::InternalImageError;
 use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
 use crate::core::events::generation_events::common::{GenerationAction, GenerationModel, GenerationServiceProvider};
 use crate::core::events::generation_events::generation_enqueue_failure_event::GenerationEnqueueFailureEvent;
@@ -57,8 +57,11 @@ pub async fn handle_image_artcraft(
     None => {
       return Err(InternalImageError::NoModelSpecified);
     }
-    Some(ImageModel::GptImage1) => {
-      return Err(InternalImageError::AnyhowError(anyhow!("wrong logic: an earlier branch should have handled gpt-image-1 images for Artcraft")));
+    Some(
+      ImageModel::GptImage1 |
+      ImageModel::Midjourney
+    ) => {
+      return Err(InternalImageError::AnyhowError(anyhow!("wrong logic: another branch should handle this: {:?}", request.model)));
     }
     Some(ImageModel::Recraft3) => {
       return Err(InternalImageError::AnyhowError(anyhow!("not yet implemented in Artcraft")));

crates/desktop/artcraft/src/core/commands/enqueue/text_to_image/generic/handle_image_fal.rs

@@ -1,6 +1,6 @@
-use crate::core::commands::enqueue::image::enqueue_text_to_image_command::EnqueueTextToImageRequest;
-use crate::core::commands::enqueue::image::internal_image_error::InternalImageError;
 use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
+use crate::core::commands::enqueue::text_to_image::enqueue_text_to_image_command::EnqueueTextToImageRequest;
+use crate::core::commands::enqueue::text_to_image::internal_image_error::InternalImageError;
 use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
 use crate::core::events::generation_events::common::{GenerationAction, GenerationModel, GenerationServiceProvider};
 use crate::core::events::generation_events::generation_enqueue_failure_event::GenerationEnqueueFailureEvent;
@@ -51,8 +51,11 @@ pub async fn handle_image_fal(
     None => {
       return Err(InternalImageError::NoModelSpecified);
     }
-    Some(ImageModel::GptImage1) => {
-      return Err(InternalImageError::AnyhowError(anyhow!("wrong logic: fal is handling sora images")));
+    Some(
+      ImageModel::GptImage1 |
+      ImageModel::Midjourney
+    ) => {
+      return Err(InternalImageError::AnyhowError(anyhow!("wrong logic: another branch should handle this: {:?}", request.model)));
     }
     Some(
       ImageModel::Flux1Dev | 

crates/desktop/artcraft/src/core/commands/enqueue/text_to_image/gpt_image_1/handle_gpt_image_1.rs

@@ -1,11 +1,11 @@
-use crate::core::commands::enqueue::image::enqueue_text_to_image_command::{EnqueueTextToImageRequest, TextToImageSize};
-use crate::core::commands::enqueue::image::gpt_image_1::handle_gpt_image_1_artcraft::handle_gpt_image_1_artcraft;
-use crate::core::commands::enqueue::image::gpt_image_1::handle_gpt_image_1_sora::handle_gpt_image_1_sora;
-use crate::core::commands::enqueue::image::internal_image_error::InternalImageError;
 use crate::core::commands::enqueue::image_edit::errors::InternalContextualEditImageError;
 use crate::core::commands::enqueue::image_edit::gpt_image_1::handle_gpt_image_1_edit_artcraft::handle_gpt_image_1_edit_artcraft;
 use crate::core::commands::enqueue::image_edit::gpt_image_1::handle_gpt_image_1_edit_sora::handle_gpt_image_1_edit_sora;
 use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
+use crate::core::commands::enqueue::text_to_image::enqueue_text_to_image_command::{EnqueueTextToImageRequest, TextToImageSize};
+use crate::core::commands::enqueue::text_to_image::gpt_image_1::handle_gpt_image_1_artcraft::handle_gpt_image_1_artcraft;
+use crate::core::commands::enqueue::text_to_image::gpt_image_1::handle_gpt_image_1_sora::handle_gpt_image_1_sora;
+use crate::core::commands::enqueue::text_to_image::internal_image_error::InternalImageError;
 use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
 use crate::core::events::generation_events::common::{GenerationAction, GenerationModel, GenerationServiceProvider};
 use crate::core::events::generation_events::generation_enqueue_failure_event::GenerationEnqueueFailureEvent;

crates/desktop/artcraft/src/core/commands/enqueue/text_to_image/gpt_image_1/handle_gpt_image_1_artcraft.rs

@@ -1,8 +1,8 @@
-use crate::core::commands::enqueue::image::enqueue_text_to_image_command::{EnqueueTextToImageRequest, TextToImageSize};
-use crate::core::commands::enqueue::image::internal_image_error::InternalImageError;
 use crate::core::commands::enqueue::image_edit::enqueue_contextual_edit_image_command::{EditImageQuality, EditImageSize};
 use crate::core::commands::enqueue::image_edit::errors::InternalContextualEditImageError;
 use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
+use crate::core::commands::enqueue::text_to_image::enqueue_text_to_image_command::{EnqueueTextToImageRequest, TextToImageSize};
+use crate::core::commands::enqueue::text_to_image::internal_image_error::InternalImageError;
 use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
 use crate::core::events::generation_events::common::{GenerationAction, GenerationModel, GenerationServiceProvider};
 use crate::core::events::generation_events::generation_enqueue_failure_event::GenerationEnqueueFailureEvent;

crates/desktop/artcraft/src/core/commands/enqueue/text_to_image/gpt_image_1/handle_gpt_image_1_sora.rs

@@ -1,7 +1,8 @@
-use crate::core::commands::enqueue::image::enqueue_text_to_image_command::{EnqueueTextToImageRequest, TextToImageSize};
-use crate::core::commands::enqueue::image::internal_image_error::InternalImageError;
 use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
+use crate::core::commands::enqueue::text_to_image::enqueue_text_to_image_command::{EnqueueTextToImageRequest, TextToImageSize};
+use crate::core::commands::enqueue::text_to_image::internal_image_error::InternalImageError;
 use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
+use crate::core::events::functional_events::show_provider_login_modal_event::ShowProviderLoginModalEvent;
 use crate::core::events::generation_events::common::{GenerationAction, GenerationModel, GenerationServiceProvider};
 use crate::core::events::generation_events::generation_enqueue_failure_event::GenerationEnqueueFailureEvent;
 use crate::core::model::image_models::ImageModel;
@@ -9,6 +10,7 @@ use crate::services::sora::state::sora_credential_manager::SoraCredentialManager
 use crate::services::sora::state::sora_task_queue::SoraTaskQueue;
 use enums::common::generation_provider::GenerationProvider;
 use enums::tauri::tasks::task_type::TaskType;
+use errors::AnyhowResult;
 use fal_client::requests::queue::image_gen::enqueue_flux_pro_11_ultra_text_to_image::{enqueue_flux_pro_11_ultra_text_to_image, FluxPro11UltraTextToImageArgs};
 use log::{error, info};
 use openai_sora_client::recipes::maybe_upgrade_or_renew_session::maybe_upgrade_or_renew_session;
@@ -26,12 +28,19 @@ pub async fn handle_gpt_image_1_sora(
   sora_task_queue: &SoraTaskQueue,
 ) -> Result<TaskEnqueueSuccess, InternalImageError> {
 
-  let mut creds = sora_creds_manager
-      .get_credentials_required()
-      .map_err(|err| {
-        error!("EnqueueTextToImage Sora creds required: {:?}", err);
-        InternalImageError::NeedsFalApiKey
-      })?;
+  let mut creds = match sora_creds_manager.get_credentials() {
+    Ok(Some(creds)) => creds,
+    Ok(None) => {
+      error!("Sora credentials not found.");
+      ShowProviderLoginModalEvent::send_for_provider(GenerationProvider::Sora, &app);
+      return Err(InternalImageError::NeedsSoraCredentials);
+    }
+    Err(err) => {
+      error!("Error reading Sora credentials: {:?}", err);
+      ShowProviderLoginModalEvent::send_for_provider(GenerationProvider::Sora, &app);
+      return Err(InternalImageError::NeedsSoraCredentials);
+    }
+  };
 
   let credential_updated = maybe_upgrade_or_renew_session(&mut creds)
       .await

crates/desktop/artcraft/src/core/commands/enqueue/text_to_image/internal_image_error.rs

@@ -2,6 +2,7 @@ use crate::core::artcraft_error::ArtcraftError;
 use base64::DecodeError;
 use errors::AnyhowError;
 use fal_client::error::fal_error_plus::FalErrorPlus;
+use midjourney_client::error::midjourney_error::MidjourneyError;
 use openai_sora_client::sora_error::SoraError;
 use storyteller_client::error::storyteller_error::StorytellerError;
 
@@ -10,9 +11,18 @@ pub enum InternalImageError {
   NoModelSpecified,
   NoProviderAvailable,
   NeedsFalApiKey,
+
+  NeedsMidjourneyCredentials,
+  NeedsMidjourneyUserInfo,
+  NeedsMidjourneyUserId,
+
+  /// Generic - possibly this came with an error message that we sent as an event.
+  MidjourneyJobEnqueueFailed,
+
   NeedsSoraCredentials,
   NeedsStorytellerCredentials,
   FalError(FalErrorPlus),
+  MidjourneyError(MidjourneyError),
   SoraError(SoraError),
   AnyhowError(AnyhowError),
   StorytellerError(StorytellerError),

crates/desktop/artcraft/src/core/commands/enqueue/text_to_image/midjourney/handle_midjourney.rs

@@ -0,0 +1,146 @@
+use crate::core::commands::enqueue::image_edit::enqueue_contextual_edit_image_command::{EditImageQuality, EditImageSize};
+use crate::core::commands::enqueue::image_edit::errors::InternalContextualEditImageError;
+use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
+use crate::core::commands::enqueue::text_to_image::enqueue_text_to_image_command::{EnqueueTextToImageRequest, TextToImageSize};
+use crate::core::commands::enqueue::text_to_image::internal_image_error::InternalImageError;
+use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
+use crate::core::events::functional_events::canvas_background_removal_complete_event::CanvasBackgroundRemovalCompleteEvent;
+use crate::core::events::functional_events::show_provider_login_modal_event::ShowProviderLoginModalEvent;
+use crate::core::events::generation_events::common::{GenerationAction, GenerationModel, GenerationServiceProvider};
+use crate::core::events::generation_events::generation_enqueue_failure_event::GenerationEnqueueFailureEvent;
+use crate::core::events::warning_events::flash_user_input_error_event::FlashUserInputErrorEvent;
+use crate::core::model::image_models::ImageModel;
+use crate::core::state::app_env_configs::app_env_configs::AppEnvConfigs;
+use crate::core::state::data_dir::app_data_root::AppDataRoot;
+use crate::core::state::provider_priority::ProviderPriorityStore;
+use crate::services::midjourney::state::midjourney_credential_manager::MidjourneyCredentialManager;
+use crate::services::sora::state::sora_credential_manager::SoraCredentialManager;
+use crate::services::sora::state::sora_task_queue::SoraTaskQueue;
+use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
+use artcraft_api_defs::generate::image::generate_gpt_image_1_text_to_image::{GenerateGptImage1TextToImageImageQuality, GenerateGptImage1TextToImageImageSize, GenerateGptImage1TextToImageNumImages, GenerateGptImage1TextToImageRequest};
+use enums::common::generation_provider::GenerationProvider;
+use enums::tauri::tasks::task_type::TaskType;
+use fal_client::requests::queue::image_gen::enqueue_flux_pro_11_ultra_text_to_image::{enqueue_flux_pro_11_ultra_text_to_image, FluxPro11UltraTextToImageArgs};
+use idempotency::uuid::generate_random_uuid;
+use log::{error, info};
+use midjourney_client::client::midjourney_hostname::MidjourneyHostname;
+use midjourney_client::endpoints::submit_job::{submit_job, SubmitJobRequest};
+use midjourney_client::error::midjourney_api_error::MidjourneyApiError;
+use midjourney_client::recipes::channel_id::ChannelId;
+use midjourney_client::recipes::text_to_image::{text_to_image, TextToImageError, TextToImageRequest};
+use openai_sora_client::recipes::maybe_upgrade_or_renew_session::maybe_upgrade_or_renew_session;
+use openai_sora_client::recipes::simple_image_gen_with_session_auto_renew::{simple_image_gen_with_session_auto_renew, SimpleImageGenAutoRenewRequest};
+use openai_sora_client::requests::image_gen::common::{ImageSize, NumImages};
+use std::time::Duration;
+use storyteller_client::generate::image::edit::gpt_image_1_edit_image::gpt_image_1_edit_image;
+use storyteller_client::generate::image::generate_gpt_image_1_text_to_image::generate_gpt_image_1_text_to_image;
+use tauri::AppHandle;
+use tokens::tokens::media_files::MediaFileToken;
+
+pub async fn handle_midjourney(
+  app: &AppHandle,
+  request: EnqueueTextToImageRequest,
+  app_env_configs: &AppEnvConfigs,
+  mj_creds_manager: &MidjourneyCredentialManager,
+) -> Result<TaskEnqueueSuccess, InternalImageError> {
+
+  let creds = match mj_creds_manager.maybe_copy_cookie_store() {
+    Ok(Some(creds)) => creds,
+    Ok(None) => {
+      error!("Midjourney credentials not found.");
+      ShowProviderLoginModalEvent::send_for_provider(GenerationProvider::Midjourney, &app);
+      return Err(InternalImageError::NeedsMidjourneyCredentials);
+    }
+    Err(err) => {
+      error!("Error reading Midjourney credentials: {:?}", err);
+      ShowProviderLoginModalEvent::send_for_provider(GenerationProvider::Midjourney, &app);
+      return Err(InternalImageError::NeedsMidjourneyCredentials);
+    },
+  };
+
+  // TODO: We can request population of the user info if absent or expired.
+  
+  let user_info = match mj_creds_manager.maybe_copy_user_info() {
+    Ok(Some(user_info)) => user_info,
+    Ok(None) => {
+      return Err(InternalImageError::NeedsMidjourneyUserInfo);
+    }
+    Err(err) => {
+      error!("Error reading Midjourney user info: {:?}", err);
+      return Err(InternalImageError::NeedsMidjourneyUserInfo);
+    },
+  };
+
+  let channel_id = match user_info.user_id {
+    Some(user_id) => ChannelId::UserId(user_id),
+    None => {
+      error!("Midjourney user info does not contain a user ID.");
+      return Err(InternalImageError::NeedsMidjourneyUserId);
+    }
+  };
+
+  info!("Calling midjourney ...");
+
+  let cookie_header = creds.to_cookie_string();
+
+  let prompt = request.prompt
+      .as_deref()
+      .unwrap_or("");
+
+  let result = text_to_image(TextToImageRequest {
+    prompt,
+    channel_id: &channel_id,
+    hostname: MidjourneyHostname::Standard,
+    cookie_header,
+  }).await;
+
+  let result = match result {
+    Ok(result) => result,
+    Err(err) => {
+      error!("Failed to use MidJourney: {:?}", err);
+      return Err(InternalImageError::MidjourneyError(err));
+    }
+  };
+  
+  let job_id = match result.maybe_job_id {
+    Some(job_id) => job_id,
+    None => {
+      error!("Failed to enqueue MidJourney: No job ID returned.");
+      return handle_midjourney_errors(app, result.maybe_errors);
+    }
+  };
+
+  info!("Successfully enqueued MidJourney. Job token: {}", job_id);
+
+  Ok(TaskEnqueueSuccess {
+    provider: GenerationProvider::Midjourney,
+    model: Some(GenerationModel::Midjourney),
+    provider_job_id: Some(job_id),
+    task_type: TaskType::ImageGeneration,
+  })
+}
+
+fn handle_midjourney_errors(
+  app: &AppHandle,
+  maybe_errors: Option<Vec<TextToImageError>>
+) -> Result<TaskEnqueueSuccess, InternalImageError> {
+  if let Some(errors) = maybe_errors {
+    if !errors.is_empty() {
+      let messages: Vec<String> = errors.iter()
+          .map(|e| format!("{:?}", e))
+          .collect();
+
+      let combined_message = messages.join("; ");
+
+      let event = FlashUserInputErrorEvent {
+        message: format!("Midjourney Error: {}", combined_message),
+      };
+
+      if let Err(err) = event.send(&app) {
+        error!("Failed to send FlashUserInputErrorEvent: {:?}", err); // Fail open
+      }
+    }
+  }
+  
+  Err(InternalImageError::MidjourneyJobEnqueueFailed)
+}

crates/desktop/artcraft/src/core/commands/enqueue/text_to_image/midjourney/mod.rs

@@ -0,0 +1 @@
+pub (super) mod handle_midjourney;

crates/desktop/artcraft/src/core/commands/enqueue/text_to_image/mod.rs

@@ -1,4 +1,5 @@
 pub mod enqueue_text_to_image_command;
 pub mod generic;
 pub mod internal_image_error;
-mod gpt_image_1;
+mod gpt_image_1;
+mod midjourney;

crates/desktop/artcraft/src/core/events/functional_events/mod.rs

@@ -1 +1,3 @@
-pub mod canvas_background_removal_complete_event;
+pub mod canvas_background_removal_complete_event;
+pub mod refresh_account_state_event;
+pub mod show_provider_login_modal_event;

crates/desktop/artcraft/src/core/events/functional_events/refresh_account_state_event.rs

@@ -0,0 +1,19 @@
+use crate::core::events::basic_sendable_event_trait::{BasicEventStatus, BasicSendableEvent};
+use enums::common::generation_provider::GenerationProvider;
+use enums::tauri::ux::tauri_event_name::TauriEventName;
+use serde_derive::Serialize;
+
+/// Send a signal to the frontend that an account state has changed: login, 
+/// logout, invalidated, etc.
+#[derive(Clone, Debug, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub struct RefreshAccountStateEvent {
+  /// The frontend can optionally decide whether it wants to refresh based 
+  /// on the impacted provider account.
+  pub provider: Option<GenerationProvider>,
+}
+
+impl BasicSendableEvent for RefreshAccountStateEvent {
+  const FRONTEND_EVENT_NAME: TauriEventName = TauriEventName::RefreshAccountStateEvent;
+  const EVENT_STATUS: BasicEventStatus = BasicEventStatus::Success;
+}

crates/desktop/artcraft/src/core/events/functional_events/show_provider_login_modal_event.rs

@@ -0,0 +1,28 @@
+use crate::core::events::basic_sendable_event_trait::{BasicEventStatus, BasicSendableEvent};
+use crate::core::events::sendable_event_error::SendableEventError;
+use enums::common::generation_provider::GenerationProvider;
+use enums::tauri::ux::tauri_event_name::TauriEventName;
+use log::error;
+use serde_derive::Serialize;
+use tauri::AppHandle;
+
+/// Send a signal to the frontend to show a modal that suggests service setup.
+#[derive(Clone, Debug, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub struct ShowProviderLoginModalEvent {
+  pub provider: GenerationProvider,
+}
+
+impl ShowProviderLoginModalEvent {
+  pub fn send_for_provider(provider: GenerationProvider, app: &AppHandle) {
+    let event = Self { provider };
+    if let Err(err) = event.send(&app) {
+      error!("Failed to send ShowProviderLoginModalEvent: {:?}", err); // Fail open
+    }
+  }
+}
+
+impl BasicSendableEvent for ShowProviderLoginModalEvent {
+  const FRONTEND_EVENT_NAME: TauriEventName = TauriEventName::ShowProviderLoginModalEvent;
+  const EVENT_STATUS: BasicEventStatus = BasicEventStatus::Failure;
+}

crates/desktop/artcraft/src/core/events/generation_events/common.rs

@@ -5,6 +5,7 @@ use serde::Serialize;
 pub enum GenerationServiceProvider {
   Artcraft,
   Fal,
+  Midjourney,
   Sora,
 }
 
@@ -30,6 +31,10 @@ pub enum GenerationModel {
   #[serde(rename = "hunyuan_3d_2_1")]
   Hunyuan3d2_1,
 
+  // Generic Midjourney model, version unknown.
+  #[serde(rename = "midjourney")]
+  Midjourney,
+
   // TODO: Should be Kling16Pro
   #[serde(rename = "kling_1.6")]
   Kling1_6,

crates/desktop/artcraft/src/core/events/mod.rs

@@ -1,5 +1,6 @@
 pub mod basic_sendable_event_trait;
+pub mod functional_events;
 pub mod generation_events;
 pub mod sendable_event_error;
 pub mod sendable_event_trait;
-pub mod functional_events;
+pub mod warning_events;

crates/desktop/artcraft/src/core/events/warning_events/flash_user_input_error_event.rs

@@ -0,0 +1,14 @@
+use crate::core::events::basic_sendable_event_trait::{BasicEventStatus, BasicSendableEvent};
+use enums::tauri::ux::tauri_event_name::TauriEventName;
+use serde_derive::Serialize;
+
+#[derive(Clone, Debug, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub struct FlashUserInputErrorEvent {
+  pub message: String,
+}
+
+impl BasicSendableEvent for FlashUserInputErrorEvent {
+  const FRONTEND_EVENT_NAME: TauriEventName = TauriEventName::FlashUserInputErrorEvent;
+  const EVENT_STATUS: BasicEventStatus = BasicEventStatus::Failure;
+}

crates/desktop/artcraft/src/core/events/warning_events/mod.rs

@@ -0,0 +1 @@
+pub mod flash_user_input_error_event;

crates/desktop/artcraft/src/core/lifecycle/startup/handle_tauri_startup.rs

@@ -1,7 +1,7 @@
 use crate::core::lifecycle::startup::tasks::bootstrap_task_database::bootstrap_task_database;
+use crate::core::lifecycle::startup::tasks::initially_size_and_position_windows::initially_size_and_position_windows;
 use crate::core::lifecycle::startup::tasks::load_provider_priority_state::load_provider_priority_state;
 use crate::core::lifecycle::startup::tasks::set_app_log_level::set_app_log_level;
-use crate::core::lifecycle::startup::tasks::initially_size_and_position_windows::initially_size_and_position_windows;
 use crate::core::lifecycle::startup::tasks::spawn_discord_presence_thread::spawn_discord_presence_thread;
 use crate::core::lifecycle::startup::tasks::spawn_fal_task_polling_thread::spawn_fal_task_polling_thread;
 use crate::core::lifecycle::startup::tasks::spawn_main_window_thread::spawn_main_window_thread;
@@ -11,6 +11,8 @@ use crate::core::state::app_env_configs::app_env_configs::AppEnvConfigs;
 use crate::core::state::data_dir::app_data_root::AppDataRoot;
 use crate::services::fal::state::fal_credential_manager::FalCredentialManager;
 use crate::services::fal::state::fal_task_queue::FalTaskQueue;
+use crate::services::midjourney::state::midjourney_credential_manager::MidjourneyCredentialManager;
+use crate::services::midjourney::threads::midjourney_long_polling_thread::midjourney_long_polling_thread;
 use crate::services::sora::state::sora_credential_manager::SoraCredentialManager;
 use crate::services::sora::state::sora_task_queue::SoraTaskQueue;
 use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
@@ -26,6 +28,7 @@ pub async fn handle_tauri_startup(
   sora_task_queue: SoraTaskQueue,
   fal_credential_manager: FalCredentialManager,
   fal_task_queue: FalTaskQueue,
+  mj_creds_manager: MidjourneyCredentialManager,
 ) -> AnyhowResult<()> {
 
   set_app_log_level(
@@ -72,6 +75,15 @@ pub async fn handle_tauri_startup(
     &storyteller_creds_manager,
   )?;
 
+  tauri::async_runtime::spawn(midjourney_long_polling_thread(
+    app.clone(),
+    app_env_configs.clone(),
+    root.clone(),
+    task_database.clone(),
+    mj_creds_manager.clone(),
+    storyteller_creds_manager.clone(),
+  ));
+
   spawn_discord_presence_thread()?;
 
   initially_size_and_position_windows(&app, &root);

crates/desktop/artcraft/src/core/model/image_models.rs

@@ -17,4 +17,8 @@ pub enum ImageModel {
   GptImage1,
   #[serde(rename = "recraft_3")]
   Recraft3,
+  
+  // Generic Midjourney model, version unknown.
+  #[serde(rename = "midjourney")]
+  Midjourney,
 }

crates/desktop/artcraft/src/core/state/data_dir/app_credentials_dir.rs

@@ -44,4 +44,8 @@ impl AppCredentialsDir {
   pub fn get_fal_api_key_file_path(&self) -> PathBuf {
     self.path.join("fal_api_key.txt")
   }
+
+  pub fn get_midjourney_state_path(&self) -> PathBuf {
+    self.path.join("midjourney_state.json")
+  }
 }

crates/desktop/artcraft/src/core/state/data_dir/app_state_dir.rs

@@ -22,7 +22,9 @@ impl DataSubdir for AppStateDir{
 
 impl AppStateDir {
   pub fn get_tasks_sqlite_database_path(&self) -> PathBuf {
-    self.path.join("tasks_v2.sqlite")
+    // NB: This must be incremented on any change to the database schema (including comments).
+    // The database houses ephemeral content and will be migrated automatically.
+    self.path.join("tasks_v3.sqlite")
   }
 
   pub fn get_window_size_config_file(&self) -> PathBuf {

crates/desktop/artcraft/src/core/utils/enum_conversion/generation_provider.rs

@@ -6,6 +6,7 @@ pub fn to_generation_service_provider(provider: GenerationProvider) -> Generatio
   match provider {
     GenerationProvider::Artcraft => GenerationServiceProvider::Artcraft,
     GenerationProvider::Fal => GenerationServiceProvider::Fal,
+    GenerationProvider::Midjourney => GenerationServiceProvider::Midjourney,
     GenerationProvider::Sora => GenerationServiceProvider::Sora,
   }
 }

crates/desktop/artcraft/src/core/utils/window/get_webview_window_hostname.rs

@@ -0,0 +1,11 @@
+use anyhow::anyhow;
+use tauri::WebviewWindow;
+use errors::AnyhowResult;
+
+pub fn get_webview_window_hostname(webview: &WebviewWindow) -> AnyhowResult<String> {
+  let url = webview.url()?;
+  let url_hostname= url.host()
+      .ok_or(anyhow!("no host in url"))?
+      .to_string();
+  Ok(url_hostname)
+}

crates/desktop/artcraft/src/core/utils/window/mod.rs

@@ -1,3 +1,4 @@
+pub mod get_webview_window_hostname;
 pub mod get_window_size_heuristic;
 pub mod position_main_window;
 pub mod resize_main_window;

crates/desktop/artcraft/src/lib.rs

@@ -5,12 +5,12 @@ use tauri::Manager;
 
 use crate::core::commands::app_preferences::get_app_preferences_command::get_app_preferences_command;
 use crate::core::commands::app_preferences::update_app_preference_command::update_app_preferences_command;
-use crate::core::commands::enqueue::image::enqueue_text_to_image_command::enqueue_text_to_image_command;
 use crate::core::commands::enqueue::image_bg_removal::enqueue_image_bg_removal_command::enqueue_image_bg_removal_command;
-use crate::core::commands::enqueue::image_inpaint::enqueue_image_inpaint_command::enqueue_image_inpaint_command;
 use crate::core::commands::enqueue::image_edit::enqueue_contextual_edit_image_command::enqueue_contextual_edit_image_command;
-use crate::core::commands::enqueue::object::enqueue_image_to_3d_object_command::enqueue_image_to_3d_object_command;
-use crate::core::commands::enqueue::video::enqueue_image_to_video_command::enqueue_image_to_video_command;
+use crate::core::commands::enqueue::image_inpaint::enqueue_image_inpaint_command::enqueue_image_inpaint_command;
+use crate::core::commands::enqueue::image_to_object::enqueue_image_to_3d_object_command::enqueue_image_to_3d_object_command;
+use crate::core::commands::enqueue::image_to_video::enqueue_image_to_video_command::enqueue_image_to_video_command;
+use crate::core::commands::enqueue::text_to_image::enqueue_text_to_image_command::enqueue_text_to_image_command;
 use crate::core::commands::flip_image::flip_image;
 use crate::core::commands::get_app_info_command::get_app_info_command;
 use crate::core::commands::load_without_cors_command::load_without_cors_command;
@@ -32,6 +32,10 @@ use crate::services::fal::commands::set_fal_api_key_command::set_fal_api_key_com
 use crate::services::fal::state::fal_credential_manager::FalCredentialManager;
 use crate::services::fal::state::fal_task_queue::FalTaskQueue;
 use crate::services::fal::threads::fal_task_polling_thread::fal_task_polling_thread;
+use crate::services::midjourney::commands::midjourney_clear_credentials_command::midjourney_clear_credentials_command;
+use crate::services::midjourney::commands::midjourney_get_credential_info_command::midjourney_get_credential_info_command;
+use crate::services::midjourney::commands::midjourney_open_login_command::midjourney_open_login_command;
+use crate::services::midjourney::state::midjourney_credential_manager::MidjourneyCredentialManager;
 use crate::services::sora::commands::check_sora_session_command::check_sora_session_command;
 use crate::services::sora::commands::open_sora_login_command::open_sora_login_command;
 use crate::services::sora::commands::sora_image_generation_command::sora_image_generation_command;
@@ -85,7 +89,10 @@ pub fn run() {
     .expect("AppEnvConfigs should be loaded from disk");
   
   let app_env_configs_2 = app_env_configs.clone();
-  
+
+  let midjourney_creds_manager = MidjourneyCredentialManager::initialize_from_disk_infallible(&app_data_root);
+  let midjourney_creds_manager_2 = midjourney_creds_manager.clone();
+
   println!("Initializing backend runtime...");
 
   tauri::Builder::default()
@@ -123,6 +130,7 @@ pub fn run() {
           sora_tasks,
           fal_creds,
           fal_tasks,
+          midjourney_creds_manager_2,
         ).await;
 
         if let Err(err) = result {
@@ -138,6 +146,7 @@ pub fn run() {
     .manage(app_preferences)
     .manage(fal_creds_manager)
     .manage(fal_task_queue)
+    .manage(midjourney_creds_manager)
     .manage(sora_creds_manager)
     .manage(sora_task_queue)
     .manage(storyteller_creds_manager_3)
@@ -159,6 +168,9 @@ pub fn run() {
       get_provider_order_command,
       load_without_cors_command,
       open_sora_login_command,
+      midjourney_clear_credentials_command,
+      midjourney_get_credential_info_command,
+      midjourney_open_login_command,
       platform_info_command,
       set_fal_api_key_command,
       set_provider_order_command,

crates/desktop/artcraft/src/services/fal/commands/fal_background_removal_command.rs

@@ -261,6 +261,7 @@ pub async fn remove_background(
     maybe_creds: Some(&creds),
     path: result_filename,
     is_intermediate_system_file: true, // NB: Probably not essential to keep this.
+    maybe_prompt_token: None, // NB: Not used for bg removal.
   }).await?;
 
   // TODO: Don't re-request to simply build MediaLinks (or CDN URL). Get those from the upload API in one turn.

crates/desktop/artcraft/src/services/fal/threads/fal_task_polling_thread.rs

@@ -125,7 +125,8 @@ async fn polling_loop(
       let result = upload_media_file_from_file(
         &app_env_configs.storyteller_host,
         Some(&storyteller_creds),
-        download_file
+        download_file,
+        None, // TODO: Should probably save prompts.
       ).await;
 
       match result {

crates/desktop/artcraft/src/services/midjourney/commands/midjourney_clear_credentials_command.rs

@@ -0,0 +1,41 @@
+use crate::core::commands::response::shorthand::{Response, SimpleResponse};
+use crate::services::fal::state::fal_credential_manager::FalCredentialManager;
+use crate::services::midjourney::state::midjourney_credential_manager::MidjourneyCredentialManager;
+use errors::AnyhowResult;
+use fal_client::creds::fal_api_key::FalApiKey;
+use log::{error, info};
+use serde_derive::Deserialize;
+use tauri::State;
+use crate::core::state::data_dir::app_data_root::AppDataRoot;
+
+#[tauri::command]
+pub async fn midjourney_clear_credentials_command(
+  root: State<'_, AppDataRoot>,
+  creds_manager: State<'_, MidjourneyCredentialManager>,
+) -> SimpleResponse {
+  info!("midjourney_clear_credentials_command called");
+
+  clear_creds(&root, &creds_manager)
+      .map_err(|err| {
+        error!("Error clearing creds: {:?}", err);
+        "error clearing creds"
+      })?;
+
+  Ok(().into())
+}
+
+fn clear_creds(
+  root: &AppDataRoot,
+  creds: &MidjourneyCredentialManager,
+) -> AnyhowResult<()> {
+
+  creds.clear_credentials()?;
+  creds.persist_to_disk()?;
+
+  let creds_path = root.credentials_dir().get_midjourney_state_path();
+  if creds_path.exists() {
+    std::fs::remove_file(creds_path)?;
+  }
+  
+  Ok(())
+}

crates/desktop/artcraft/src/services/midjourney/commands/midjourney_get_credential_info_command.rs

@@ -0,0 +1,53 @@
+use crate::core::commands::response::shorthand::{Response, ResponseOrErrorMessage};
+use crate::core::commands::response::success_response_wrapper::SerializeMarker;
+use crate::services::fal::state::fal_credential_manager::FalCredentialManager;
+use crate::services::midjourney::state::midjourney_credential_manager::MidjourneyCredentialManager;
+use errors::AnyhowResult;
+use log::{error, info};
+use serde_derive::Serialize;
+use tauri::State;
+
+#[derive(Serialize)]
+pub struct MidjourneyGetCredentialInfoResponse {
+  pub maybe_email: Option<String>,
+  pub can_clear_state: bool,
+}
+
+impl SerializeMarker for MidjourneyGetCredentialInfoResponse {}
+
+#[tauri::command]
+pub async fn midjourney_get_credential_info_command(
+  creds_manager: State<'_, MidjourneyCredentialManager>,
+) -> ResponseOrErrorMessage<MidjourneyGetCredentialInfoResponse> {
+  info!("midjourney_get_credential_info_command called");
+
+  let info = get_info(&creds_manager)
+      .map_err(|err| {
+        error!("Error getting info: {:?}", err);
+        "error getting info"
+      })?;
+
+  Ok(info.into())
+}
+
+fn get_info(
+  creds: &MidjourneyCredentialManager,
+) -> AnyhowResult<MidjourneyGetCredentialInfoResponse> {
+  let mut can_clear_state = true;
+  
+  let maybe_cookies = creds.maybe_copy_cookie_store()?;
+  let maybe_user_info = creds.maybe_copy_user_info()?;
+  
+  if maybe_cookies.is_none()  && maybe_user_info.is_none() {
+    can_clear_state = false;
+  }
+  
+  let maybe_email = maybe_user_info
+      .map(|info| info.email.clone())
+      .flatten();
+  
+  Ok(MidjourneyGetCredentialInfoResponse {
+    maybe_email,
+    can_clear_state,
+  })
+}

crates/desktop/artcraft/src/services/midjourney/commands/midjourney_open_login_command.rs

@@ -0,0 +1,38 @@
+use crate::core::state::data_dir::app_data_root::AppDataRoot;
+use crate::services::midjourney::state::midjourney_credential_manager::MidjourneyCredentialManager;
+use crate::services::midjourney::windows::open_midjourney_login_window::open_midjourney_login_window;
+use crate::services::sora::windows::sora_login_window::open_sora_login_window::open_sora_login_window;
+use errors::AnyhowResult;
+use log::{error, info};
+use tauri::{AppHandle, State};
+
+#[tauri::command]
+pub async fn midjourney_open_login_command(
+  app: AppHandle,
+  app_data_root: State<'_, AppDataRoot>,
+  mj_creds_manager: State<'_, MidjourneyCredentialManager>,
+) -> Result<String, String> {
+  info!("midjourney_open_login_command called");
+
+  do_open_login(&app, &app_data_root, &mj_creds_manager)
+      .await
+      .map_err(|err| {
+        error!("Error opening login: {:?}", err);
+        format!("Error opening login: {:?}", err)
+      })?;
+
+  Ok("result".to_string())
+}
+
+async fn do_open_login(
+  app: &AppHandle,
+  app_data_root: &AppDataRoot,
+  mj_creds_manager: &MidjourneyCredentialManager,
+) -> AnyhowResult<()> {
+  info!("Building login window...");
+
+  open_midjourney_login_window(app, app_data_root, mj_creds_manager).await?;
+
+  info!("Done.");
+  Ok(())
+}