ruby_everywhere 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3a05ca6c42372f257d9fdcbd1ff0e7b2becbceb64e533e671ab5b9b222f7fff
-  data.tar.gz: 6905e9cc0e07e0cf221d0a9219b9ddcdbe43ddfee67d844d5d7d2824f92291c6
+  metadata.gz: 6e02deeb4f95a031a3a44bae0e87dbaece25f95a919ff817927e9eb5b611ffbb
+  data.tar.gz: db779e7819a864517b0a44a388c56b835eb724a2d697af653857936cab505ac1
 SHA512:
-  metadata.gz: 755a57a26107f6f6f95d0ef30b14b9f83d67d172ac4aba0fbff629326e4db013b6aa094d16b558b9e84b147d8faff6e93a524df53b0976e5282e156026a87cd1
-  data.tar.gz: 1ab5013257d9d4716c8ea27a23ada758474be29dae9cb34d204925dde1cd82fe3046faf10e92cd18242507c6cb7c911bdc3bea9d2dd358507389a4d3584dcf18
+  metadata.gz: a1567ed4df49616f1c05fe481812a62bc9f3eb64e816e4702756a0614e282027016a4e76ad62a3097fced1bde908a22fdba8ae6b6b6a46aa24cdc227bb8bf32e
+  data.tar.gz: ed2ecc0ff275c958291986eb8ea23b0e9fde277b62dcffc614c61dd84f2d6c4c626e8c93d07a8563b4755cb036f56f4a0107e00cc6c46280c6e61c551e259c1e

data/bridge/README.md

@@ -0,0 +1,77 @@
+# @rubyeverywhere/bridge
+
+One API for the browser, the RubyEverywhere desktop shell, and (soon) Hotwire
+Native mobile apps — the JavaScript half of [RubyEverywhere](https://rubyeverywhere.com).
+
+App code writes to this surface only; platform differences live in adapters
+inside the package. Everything degrades gracefully: the same page works in a
+plain browser tab and gains native powers inside a RubyEverywhere app.
+
+## Install
+
+```sh
+npm install @rubyeverywhere/bridge
+```
+
+Using RubyEverywhere? You don't need npm at all: the `ruby_everywhere` gem
+ships this exact package. Rails apps get it served and importmap-pinned by the
+gem's engine (updates arrive with `bundle update ruby_everywhere`); Sinatra and
+Hanami apps get it vendored to `public/bridge.js` by `every install`.
+
+## Usage
+
+```js
+import Everywhere from "@rubyeverywhere/bridge"
+
+Everywhere.platform                  // "desktop" | "mobile" | "browser"
+Everywhere.os                        // "macos" | "windows" | "linux" | "ios" | "android" | "chromeos" | "unknown"
+Everywhere.native                    // true inside a RubyEverywhere app
+Everywhere.version                   // app version; null in a plain browser tab
+
+Everywhere.notify({ title, body })   // native notification / web Notification / console
+Everywhere.confirm("Sure?")          // Promise<boolean>, native dialog when possible
+Everywhere.on("menu", handler)       // shell events; returns an unsubscribe fn
+Everywhere.visit("/settings")        // Turbo.visit with location fallback
+
+Everywhere.clipboard.write(text)     // Promise<void>
+Everywhere.clipboard.read()          // Promise<string | null>
+```
+
+### Auto-updates
+
+Inside the desktop shell, apps with an update feed configured can check,
+install, and switch channels at runtime:
+
+```js
+Everywhere.updates.supported          // true when the shell has an update feed
+Everywhere.updates.channel            // effective channel ("stable", "beta", …)
+
+const result = await Everywhere.updates.check()
+// { available: true, version, notes, notesHtml } or { available: false }
+
+Everywhere.updates.install()          // download / verify / swap / relaunch
+Everywhere.updates.setChannel("beta") // Promise<{ channel }>, persisted by the shell
+
+Everywhere.updates.on("available", handler)
+// events: "available" | "none" | "progress" | "ready" | "error" | "channel"
+```
+
+`notes` is the release-notes markdown source; `notesHtml` is the same notes
+pre-rendered to HTML from your signed update feed, ready for a changelog
+modal: `el.innerHTML = notesHtml`.
+
+In a plain browser tab the updates API is inert: `check()` resolves
+`{ available: false, unsupported: true }` and nothing throws.
+
+## Platforms
+
+- **desktop** — the Tauri-based RubyEverywhere shell. Notifications, dialogs,
+  clipboard, shell events, and auto-updates are native.
+- **browser** — honest web fallbacks: the Notification API, `window.confirm`,
+  `navigator.clipboard`, DOM CustomEvents.
+- **mobile** — Hotwire Native detection is live; behavior currently falls back
+  to the browser adapter until the bridge-component adapter lands.
+
+## License
+
+MIT

data/{lib/everywhere/javascript → bridge/everywhere}/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/bridge/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@rubyeverywhere/bridge",
+  "version": "0.3.0",
+  "description": "One API for browser, desktop, and mobile — the JS half of RubyEverywhere",
+  "type": "module",
+  "main": "everywhere/bridge.js",
+  "exports": { ".": "./everywhere/bridge.js" },
+  "files": ["everywhere/bridge.js", "README.md"],
+  "sideEffects": false,
+  "keywords": ["rubyeverywhere", "tauri", "hotwire", "turbo", "rails", "desktop", "native", "bridge"],
+  "homepage": "https://rubyeverywhere.com",
+  "license": "MIT",
+  "publishConfig": { "access": "public" }
+}

data/config/importmap.rb

@@ -0,0 +1,3 @@
+# Pin drawn into apps by Everywhere::Engine (before the app's own importmap,
+# which can therefore override it).
+pin "@rubyeverywhere/bridge", to: "everywhere/bridge.js"

data/lib/everywhere/commands/install.rb

@@ -66,7 +66,7 @@ module Everywhere
       # Rack frameworks vary too much to auto-edit their boot files safely, so we
       # vendor the bridge and print the remaining wiring rather than guess.
       def vendor_bridge_to_public
-        source = File.expand_path("../javascript/bridge.js", __dir__)
+        source = File.expand_path("../../../bridge/everywhere/bridge.js", __dir__)
         target_dir = app_file("public")
         FileUtils.mkdir_p(target_dir)
         target = File.join(target_dir, "bridge.js")
@@ -219,32 +219,36 @@ module Everywhere
         change("disable force_ssl for localhost", made)
       end
 
-      # Vendor @rubyeverywhere/bridge (one JS API across browser/desktop/mobile)
-      # and pin it for importmap. Re-running `every install` after a gem update
-      # refreshes the vendored copy.
+      # @rubyeverywhere/bridge (one JS API across browser/desktop/mobile) is
+      # served and pinned by Everywhere::Engine straight from the gem, so the
+      # bridge updates with `bundle update ruby_everywhere`. Nothing to vendor —
+      # just migrate apps installed before the engine existed (their vendored
+      # copy and pin would shadow the engine's, freezing them on an old bridge)
+      # and wire the import.
       def install_bridge
-        source = File.expand_path("../javascript/bridge.js", __dir__)
-        target_dir = app_file("vendor", "javascript")
-        target = File.join(target_dir, "@rubyeverywhere--bridge.js")
-        FileUtils.mkdir_p(target_dir)
-        # Stamp a machine-readable version marker on the vendored copy so the
-        # build receipt (Receipt#bridge_version) can record which bridge shipped.
-        # Comparing against the fully-stamped content keeps re-runs idempotent.
-        desired = "// @rubyeverywhere/bridge version: #{Everywhere::BRIDGE_VERSION} (vendored by `every install`)\n#{File.read(source)}"
-        fresh = !File.exist?(target) || File.read(target) != desired
-        File.write(target, desired) if fresh
+        fresh = remove_vendored_bridge
 
         importmap = app_file("config", "importmap.rb")
         if File.exist?(importmap)
           contents = File.read(importmap)
-          unless contents.include?("@rubyeverywhere/bridge")
-            File.write(importmap, contents.chomp + "\npin \"@rubyeverywhere/bridge\", to: \"@rubyeverywhere--bridge.js\" # vendored by `every install`\n")
+          stale_pin = /^pin ["']@rubyeverywhere\/bridge["'],\s*to:\s*["']@rubyeverywhere--bridge\.js["'].*\n/
+          if contents.match?(stale_pin)
+            File.write(importmap, contents.gsub(stale_pin, ""))
             fresh = true
           end
         end
         wire_application_js(fresh)
       end
 
+      def remove_vendored_bridge
+        target = app_file("vendor", "javascript", "@rubyeverywhere--bridge.js")
+        return false unless File.exist?(target)
+
+        FileUtils.rm(target)
+        change("remove vendored bridge (now served by the ruby_everywhere engine)", true)
+        true
+      end
+
       def wire_application_js(fresh)
         app_js = app_file("app", "javascript", "application.js")
         if File.exist?(app_js)

data/lib/everywhere/engine.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Everywhere
+  # Rails integration: serves @rubyeverywhere/bridge straight from the gem's
+  # bridge/ directory (the same files published to npm — single source) and
+  # contributes the importmap pin, so apps get bridge updates with
+  # `bundle update ruby_everywhere` — no vendored copy to refresh. Loaded only
+  # when Rails is present; Sinatra/Hanami apps keep the vendored
+  # public/bridge.js from `every install`.
+  class Engine < ::Rails::Engine
+    # bridge/ becomes an asset root, so bridge/everywhere/bridge.js gets the
+    # namespaced logical path "everywhere/bridge.js" (Propshaft and Sprockets
+    # both read config.assets.paths); Sprockets additionally needs the file
+    # declared precompilable.
+    initializer "everywhere.assets" do |app|
+      if app.config.respond_to?(:assets)
+        app.config.assets.paths << Engine.root.join("bridge").to_s
+        app.config.assets.precompile += %w[everywhere/bridge.js] if app.config.assets.respond_to?(:precompile)
+      end
+    end
+
+    # Runs before importmap-rails adds the app's config/importmap.rb, so an
+    # app-level pin (e.g. a legacy vendored copy) still overrides ours.
+    initializer "everywhere.importmap", before: "importmap" do |app|
+      if app.config.respond_to?(:importmap)
+        app.config.importmap.paths << Engine.root.join("config/importmap.rb")
+      end
+    end
+  end
+end

data/lib/everywhere/receipt.rb

@@ -116,10 +116,18 @@ module Everywhere
         File.join(@root, "vendor", "javascript", "@rubyeverywhere", "bridge", "package.json")
       ].each { |p| (v = json_version(p)) and return v }
 
-      # Single-file vendored install: read a `// version: x.y.z` header marker
-      # if `every install` stamped one (best-effort until it does).
+      # Legacy single-file vendored install: read the `// version: x.y.z`
+      # marker `every install` stamped on the copy.
       flat = File.join(@root, "vendor", "javascript", "@rubyeverywhere--bridge.js")
-      File.exist?(flat) ? File.foreach(flat).first(6).join[/version:\s*([\d.]+)/i, 1] : nil
+      return File.foreach(flat).first(6).join[/version:\s*([\d.]+)/i, 1] if File.exist?(flat)
+
+      # Engine-served (Rails apps bundling ruby_everywhere): the bridge ships
+      # inside the gem, so it carries the gem's BRIDGE_VERSION. Best-effort —
+      # assumes the app bundles the same gem release that's running this build.
+      lock = File.join(@root, "Gemfile.lock")
+      return Everywhere::BRIDGE_VERSION if File.exist?(lock) && File.read(lock).match?(/^\s+ruby_everywhere\s/)
+
+      nil
     end
 
     def shell_version

data/lib/everywhere/version.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
 module Everywhere
-  VERSION = "0.1.8"
+  VERSION = "0.1.10"
 
-  # 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"
+  # Version of the @rubyeverywhere/bridge JS this gem ships. bridge/ in the
+  # gem IS the npm package (served to Rails apps by Everywhere::Engine,
+  # vendored to public/ for Sinatra/Hanami), so its package.json is the single
+  # source of truth. The build receipt records it; it versions independently
+  # of the CLI.
+  BRIDGE_VERSION = File.read(
+    File.expand_path("../../bridge/package.json", __dir__)
+  )[/"version":\s*"([^"]+)"/, 1]
 end

data/lib/everywhere.rb

@@ -7,6 +7,9 @@ require_relative "everywhere/config"
 require_relative "everywhere/framework"
 require_relative "everywhere/database"
 require_relative "everywhere/boot"
+# Rails apps get the bridge served + pinned by the engine (Sinatra/Hanami
+# vendor it to public/ instead — see `every install`).
+require_relative "everywhere/engine" if defined?(::Rails::Engine)
 
 module Everywhere
   class Error < StandardError; 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.10
 platform: ruby
 authors:
 - Andrea Fomera
@@ -75,6 +75,10 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- bridge/README.md
+- bridge/everywhere/bridge.js
+- bridge/package.json
+- config/importmap.rb
 - exe/every
 - exe/rbe
 - lib/everywhere.rb
@@ -98,10 +102,10 @@ files:
 - lib/everywhere/commands/updates_keygen.rb
 - lib/everywhere/config.rb
 - lib/everywhere/database.rb
+- lib/everywhere/engine.rb
 - lib/everywhere/framework.rb
 - lib/everywhere/icon.rb
 - lib/everywhere/ignore.rb
-- lib/everywhere/javascript/bridge.js
 - lib/everywhere/log_filter.rb
 - lib/everywhere/minisign.rb
 - lib/everywhere/paths.rb