ruby_everywhere 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3a05ca6c42372f257d9fdcbd1ff0e7b2becbceb64e533e671ab5b9b222f7fff
-  data.tar.gz: 6905e9cc0e07e0cf221d0a9219b9ddcdbe43ddfee67d844d5d7d2824f92291c6
+  metadata.gz: b0f0efd687867d44e9b4223bd1bcdda51dd543236d8510069d9232b81e5e31dd
+  data.tar.gz: 4070286991240decb7b38abc1766a360e996153d8640f8a1f1c6339f247de6d9
 SHA512:
-  metadata.gz: 755a57a26107f6f6f95d0ef30b14b9f83d67d172ac4aba0fbff629326e4db013b6aa094d16b558b9e84b147d8faff6e93a524df53b0976e5282e156026a87cd1
-  data.tar.gz: 1ab5013257d9d4716c8ea27a23ada758474be29dae9cb34d204925dde1cd82fe3046faf10e92cd18242507c6cb7c911bdc3bea9d2dd358507389a4d3584dcf18
+  metadata.gz: a5ba33fca0834b228b5567695414896cc218adc5d082a2ea46c33f728148f8b9f2fbfc09ab0455a5473f8f6a327352f9e38b489364092fe7f842e9e6a395a244
+  data.tar.gz: e6067ab08a817595a5076be7bdbd8dbb7a3a06964bbc5682409e4ad2a2cd7c1d7e87b07a4e6bd93e0ac48964553b70f0f3dbfd6fb693da53ccde51a7e3b5e3ae

data/lib/everywhere/javascript/bridge.js

@@ -17,9 +17,11 @@
 //   Everywhere.visit("/settings")        // Turbo.visit with location fallback
 //
 //   Everywhere.updates.supported         // true when the shell has an update feed
+//   Everywhere.updates.channel           // effective channel ("stable", "beta", …)
 //   Everywhere.updates.check()           // Promise<{available, version?, notes?, notesHtml?}>
 //   Everywhere.updates.install()         // download/verify/swap/relaunch
-//   Everywhere.updates.on("available" | "none" | "progress" | "ready" | "error", handler)
+//   Everywhere.updates.setChannel("beta")// Promise<{channel}>, persisted by the shell
+//   Everywhere.updates.on("available" | "none" | "progress" | "ready" | "error" | "channel", handler)
 //
 //   notes is the markdown source; notesHtml is the same notes pre-rendered to
 //   HTML (from the signed update feed — your own content), ready for a
@@ -110,6 +112,25 @@ const desktop = {
 
   updatesInstall() {
     return window.__TAURI__.event.emit("everywhere:update-install", {})
+  },
+
+  // Ask the shell to switch update channels. The shell validates, persists the
+  // choice (it survives relaunches and overrides everywhere.yml), and always
+  // answers: update-channel on success, update-error on rejection.
+  updatesSetChannel(channel) {
+    return new Promise((resolve, reject) => {
+      const offs = []
+      let timer = null
+      const settle = (fn) => (payload) => {
+        offs.forEach((off) => off())
+        clearTimeout(timer)
+        fn(payload)
+      }
+      offs.push(this.on("update-channel", settle((p) => resolve({ channel: p.channel }))))
+      offs.push(this.on("update-error", settle((p) => reject(new Error(p.message)))))
+      timer = setTimeout(settle(() => reject(new Error("channel change timed out"))), 10000)
+      window.__TAURI__.event.emit("everywhere:update-set-channel", { channel })
+    })
   }
 }
 
@@ -160,6 +181,11 @@ const browser = {
   updatesInstall() {
     console.log("[everywhere] updates unavailable in the browser")
     return Promise.resolve()
+  },
+
+  updatesSetChannel() {
+    console.log("[everywhere] update channel unavailable in the browser")
+    return Promise.resolve({ channel: null, unsupported: true })
   }
 }
 
@@ -182,6 +208,9 @@ const platform = detectPlatform()
 const os = detectOS()
 const adapter = adapters[platform]
 
+// Mutable so setChannel can keep updates.channel truthful without a reload.
+let updatesChannel = (config.updates && config.updates.channel) || null
+
 export const Everywhere = {
   platform,
   os,
@@ -228,7 +257,13 @@ export const Everywhere = {
       return platform === "desktop" && !!config.updates
     },
     version: config.version || null,
-    channel: (config.updates && config.updates.channel) || null,
+
+    // The channel the shell is actually checking. The shell injects the
+    // effective value (a persisted user choice overrides everywhere.yml), and
+    // setChannel keeps it current without a reload.
+    get channel() {
+      return updatesChannel
+    },
 
     check() {
       return adapter.updatesCheck()
@@ -240,6 +275,15 @@ export const Everywhere = {
       return adapter.updatesInstall()
     },
 
+    // Switch the update feed channel (e.g. "stable" -> "beta"). Resolves once
+    // the shell has persisted it; follow with check() to scan the new channel.
+    setChannel(channel) {
+      return adapter.updatesSetChannel(channel).then((result) => {
+        if (result && result.channel) updatesChannel = result.channel
+        return result
+      })
+    },
+
     on(event, handler) {
       return adapter.on(`update-${event}`, handler)
     }

data/lib/everywhere/version.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 module Everywhere
-  VERSION = "0.1.8"
+  VERSION = "0.1.9"
 
   # Version of the vendored @rubyeverywhere/bridge JS this gem ships. Tracks
   # bridge/package.json — bump it whenever lib/everywhere/javascript/bridge.js is
   # refreshed. `every install` stamps it into the vendored file so the build
   # receipt can record which bridge shipped; it versions independently of the CLI.
-  BRIDGE_VERSION = "0.2.0"
+  BRIDGE_VERSION = "0.3.0"
 end

data/support/shell/src-tauri/src/main.rs

@@ -143,6 +143,16 @@ fn main() {
         .plugin(tauri_plugin_clipboard_manager::init())
         .invoke_handler(tauri::generate_handler![notify_command])
         .setup(move |app| {
+            // A persisted user channel choice (Everywhere.updates.setChannel)
+            // overrides everywhere.yml's updates.channel. Fold it in before
+            // anything reads raw_json — the updater, the menu, and the
+            // __EVERYWHERE_CONFIG__ page injection all see the same channel.
+            let mut config = config;
+            if let Ok(mut value) = serde_json::from_str::<serde_json::Value>(&config.raw_json) {
+                updater::apply_channel_override(app.handle(), &mut value);
+                config.raw_json = value.to_string();
+            }
+
             // Bridge channel: pages emit events (the sanctioned webview->shell
             // path for remote-origin content in Tauri v2; invoke is reserved
             // for local content). Fire-and-forget, Strada-style.

data/support/shell/src-tauri/src/updater.rs

@@ -10,10 +10,16 @@
 //   codesign --verify --deep --strict -> Info.plist bundle_id + version match.
 //
 // Page JS drives it through bridge events (everywhere:update-check /
-// update-install in; update-available / -none / -progress / -ready / -error
-// out); the "Check for Updates…" menu item drives the same flows with native
-// dialogs. `updates.auto` picks the background behaviour: off | check |
-// download | install (silent swap staged in RAM-free renames on quit).
+// update-install / update-set-channel in; update-available / -none /
+// -progress / -ready / -error / -channel out); the "Check for Updates…" menu
+// item drives the same flows with native dialogs. `updates.auto` picks the
+// background behaviour: off | check | download | install (silent swap staged
+// in RAM-free renames on quit).
+//
+// Channel: everywhere.yml's updates.channel is the default; a user choice made
+// through the bridge (Everywhere.updates.setChannel) is persisted to the app
+// data dir and overrides it from then on — the server-driven settings page
+// decides who gets to see a "beta" option, the shell just honors the pick.
 
 use std::path::{Path, PathBuf};
 use std::process::Command;
@@ -61,10 +67,20 @@ struct Pending {
 
 pub struct UpdaterState {
     cfg: UpdateConfig,
+    // The live channel. Starts as cfg.channel (which already reflects a
+    // persisted override — see apply_channel_override) and moves when the page
+    // calls setChannel.
+    channel: Mutex<String>,
     pending: Mutex<Option<Pending>>,
     busy: AtomicBool,
 }
 
+impl UpdaterState {
+    fn channel(&self) -> String {
+        self.channel.lock().unwrap().clone()
+    }
+}
+
 impl UpdateConfig {
     // The shell subset of everywhere.yml's updates: section, from the same
     // raw config JSON the rest of the shell reads. None => updater disabled.
@@ -107,13 +123,31 @@ pub fn enabled(raw_json: &str) -> bool {
     UpdateConfig::parse(raw_json).is_some()
 }
 
+// Fold the persisted user channel choice (if any) into the raw config value.
+// main.rs calls this before the config is parsed OR injected into pages, so
+// the updater, the menu, and __EVERYWHERE_CONFIG__.updates.channel all agree
+// on the effective channel.
+pub fn apply_channel_override(handle: &tauri::AppHandle, value: &mut serde_json::Value) {
+    if !value["updates"].is_object() {
+        return;
+    }
+    let bundle_id = value["bundle_id"].as_str().unwrap_or("com.rubyeverywhere.app").to_string();
+    let Some(path) = channel_file(handle, &bundle_id) else { return };
+    let Ok(saved) = std::fs::read_to_string(&path) else { return };
+    let saved = saved.trim();
+    if valid_channel(saved) {
+        value["updates"]["channel"] = serde_json::json!(saved);
+    }
+}
+
 pub fn init(app: &tauri::App, raw_json: &str) {
     let Some(cfg) = UpdateConfig::parse(raw_json) else {
         return;
     };
     let auto = cfg.auto;
     let interval = cfg.interval;
-    app.manage(UpdaterState { cfg, pending: Mutex::new(None), busy: AtomicBool::new(false) });
+    let channel = Mutex::new(cfg.channel.clone());
+    app.manage(UpdaterState { cfg, channel, pending: Mutex::new(None), busy: AtomicBool::new(false) });
 
     {
         let handle = app.handle().clone();
@@ -140,6 +174,14 @@ pub fn init(app: &tauri::App, raw_json: &str) {
             });
         });
     }
+    {
+        let handle = app.handle().clone();
+        app.listen_any("everywhere:update-set-channel", move |event| {
+            let payload = event.payload().to_string();
+            let handle = handle.clone();
+            std::thread::spawn(move || set_channel(&handle, &payload));
+        });
+    }
 
     if auto != Auto::Off {
         let handle = app.handle().clone();
@@ -156,13 +198,53 @@ pub fn init(app: &tauri::App, raw_json: &str) {
 
 // ---- flows ------------------------------------------------------------------
 
+// Bridge-triggered channel switch (Everywhere.updates.setChannel). Validates,
+// persists the choice so it survives relaunches, retargets the running
+// updater, and always answers: update-channel on success, update-error on a
+// bad request. A staged download from the old channel is discarded — it no
+// longer represents what the user asked to run.
+fn set_channel(handle: &tauri::AppHandle, payload: &str) {
+    let Some(state) = state(handle) else { return };
+    let requested = serde_json::from_str::<serde_json::Value>(payload)
+        .ok()
+        .and_then(|v| v["channel"].as_str().map(str::to_string));
+    let Some(channel) = requested.filter(|c| valid_channel(c)) else {
+        emit_error(handle, "invalid update channel (letters, digits, . _ - only)");
+        return;
+    };
+
+    if let Some(path) = channel_file(handle, &state.cfg.bundle_id) {
+        let write = path
+            .parent()
+            .map(|dir| std::fs::create_dir_all(dir).map_err(|e| e.to_string()))
+            .unwrap_or(Ok(()))
+            .and_then(|()| std::fs::write(&path, &channel).map_err(|e| e.to_string()));
+        if let Err(e) = write {
+            emit_error(handle, &format!("could not save channel choice: {e}"));
+            return;
+        }
+    }
+
+    let changed = {
+        let mut current = state.channel.lock().unwrap();
+        let changed = *current != channel;
+        *current = channel.clone();
+        changed
+    };
+    if changed {
+        *state.pending.lock().unwrap() = None;
+    }
+    println!("[updater] channel set to {channel}");
+    let _ = handle.emit_to("main", "everywhere:update-channel", serde_json::json!({ "channel": channel }));
+}
+
 // Bridge-triggered check: always answers with an event (available/none/error).
 fn explicit_check(handle: &tauri::AppHandle) {
     let Some(state) = state(handle) else { return };
     if state.busy.swap(true, Ordering::SeqCst) {
         return;
     }
-    match check(&state.cfg) {
+    match check(&state.cfg, &state.channel()) {
         Ok(Some(m)) => emit_available(handle, &m),
         Ok(None) => {
             let _ = handle.emit_to("main", "everywhere:update-none",
@@ -181,7 +263,7 @@ pub fn interactive_check(handle: &tauri::AppHandle) {
     if state.busy.swap(true, Ordering::SeqCst) {
         return;
     }
-    let outcome = check(&state.cfg);
+    let outcome = check(&state.cfg, &state.channel());
     state.busy.store(false, Ordering::SeqCst);
 
     match outcome {
@@ -225,7 +307,7 @@ fn background_pass(handle: &tauri::AppHandle, auto: Auto) {
         return;
     }
     let result = (|| -> Result<(), String> {
-        let Some(m) = check(&state.cfg)? else { return Ok(()) };
+        let Some(m) = check(&state.cfg, &state.channel())? else { return Ok(()) };
         emit_available(handle, &m);
         if auto >= Auto::Download && !is_staged(&state, &m) {
             let staged = download_and_stage(handle, &state.cfg, &m)?;
@@ -252,7 +334,7 @@ fn install_flow(handle: &tauri::AppHandle) -> Result<(), String> {
     let pending = match pending {
         Some(p) => p,
         None => {
-            let m = check(&state.cfg)?.ok_or("already up to date")?;
+            let m = check(&state.cfg, &state.channel())?.ok_or("already up to date")?;
             emit_available(handle, &m);
             let staged = download_and_stage(handle, &state.cfg, &m)?;
             Pending { manifest: m, extracted_app: staged }
@@ -284,10 +366,10 @@ pub fn install_pending_on_exit(app: &tauri::AppHandle) {
 
 // ---- check ------------------------------------------------------------------
 
-fn check(cfg: &UpdateConfig) -> Result<Option<Manifest>, String> {
+fn check(cfg: &UpdateConfig, channel: &str) -> Result<Option<Manifest>, String> {
     let url = format!(
         "{}/{}/{}/{}/latest.json?current={}",
-        cfg.url, cfg.channel, os_name(), arch_name(), cfg.current
+        cfg.url, channel, os_name(), arch_name(), cfg.current
     );
     println!("[updater] checking {url}");
 
@@ -580,6 +662,19 @@ fn state(handle: &tauri::AppHandle) -> Option<tauri::State<'_, UpdaterState>> {
     handle.try_state::<UpdaterState>()
 }
 
+// Where the user's channel choice lives: <data dir>/<bundle_id>/update-channel,
+// a plain-text sibling of the updates/ staging dir.
+fn channel_file(handle: &tauri::AppHandle, bundle_id: &str) -> Option<PathBuf> {
+    handle.path().data_dir().ok().map(|d| d.join(bundle_id).join("update-channel"))
+}
+
+// Channel names become a path segment of the feed URL — keep them boring.
+fn valid_channel(s: &str) -> bool {
+    !s.is_empty()
+        && s.len() <= 64
+        && s.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '-' | '_' | '.'))
+}
+
 // notes = markdown source (also what the native dialog shows); notes_html =
 // pre-rendered HTML for in-app changelog UI. Both ride to the page untouched —
 // the feed is the developer's own signed content.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_everywhere
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - Andrea Fomera