From 010d417636feba52cc28fe0eb64c04b4a12e2250 Mon Sep 17 00:00:00 2001 From: fraa2a Date: Fri, 9 Oct 2026 13:09:22 +0200 Subject: [PATCH 01/14] fix: checkpoint bounded media workers and audit correction plan --- .github/workflows/core-tests.yml | 2 +- CLAUDE.md | 7 ++- docs/ARCHITECTURE.md | 19 +++--- .../plans/2026-10-09-audit-errors.md | 23 ++++++++ libs/recording/bounded_worker.h | 58 +++++++++++++++++++ libs/recording/media_control.h | 56 ++++++++++++++++++ tests/phase1/CMakeLists.txt | 9 +++ tests/phase1/bounded_worker_test.cpp | 35 +++++++++++ tests/phase1/media_control_test.cpp | 32 ++++++++++ 9 files changed, 228 insertions(+), 13 deletions(-) create mode 100644 docs/superpowers/plans/2026-10-09-audit-errors.md create mode 100644 libs/recording/bounded_worker.h create mode 100644 libs/recording/media_control.h create mode 100644 tests/phase1/bounded_worker_test.cpp create mode 100644 tests/phase1/media_control_test.cpp diff --git a/.github/workflows/core-tests.yml b/.github/workflows/core-tests.yml index c8bdfea..4a06e08 100644 --- a/.github/workflows/core-tests.yml +++ b/.github/workflows/core-tests.yml @@ -23,7 +23,7 @@ jobs: run: python3 scripts/check-text.py - name: Run portable native regressions run: | - for suite in phase1 phase2 u6; do + for suite in phase1 phase2 u6 logging; do cmake -S "tests/$suite" -B "build-tests/$suite" -DCMAKE_CXX_FLAGS='-Werror' cmake --build "build-tests/$suite" --parallel 2 ctest --test-dir "build-tests/$suite" --output-on-failure diff --git a/CLAUDE.md b/CLAUDE.md index 6a837f0..227e248 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -43,8 +43,9 @@ Desktop UI live in `app/desktop-ui`: ## Tests And Verification -No full auto test suite yet. No claim test verification -unless specific command run. +Portable native, Rust, browser UI, Stream Deck and Windows updater recovery +regressions run in GitHub Actions. Report exact commands and results; portable +tests do not establish real-device or clean-install behavior. Useful checks: @@ -77,7 +78,7 @@ Main modules: - `app/recorder`: `Monolith.exe`, Win32 tray, message-only window, hotkeys, lifecycle, recording/replay orchestration, runtime status, updater. - `app/desktop-ui`: `Monolith.UI.exe`, Tauri v2/WebView2 host + Preact UI. - Rust modules serve bundled frontend, expose local HTTP APIs, read clip + Rust modules serve the bundled frontend, expose Tauri commands, read clip catalogs read-only, write settings, call engine JSON-RPC. - `libs/capture`: Windows.Graphics.Capture D3D11 capture w/ CPU-readable BGRA staging path. diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 5257600..3c3d3cc 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -36,8 +36,8 @@ Long-term target = separate headless record engine process + UI/tray process in - `app/recorder`: orchestrator, tray, hotkeys, app state, settings reload, updater, runtime status, command dispatch. - `app/desktop-ui`: Tauri v2/WebView2 host + Preact frontend. Rust modules: - `server.rs`, `media.rs`, `settings_store.rs`, `clip_catalog.rs`, - `engine_rpc.rs`, `game_catalog.rs`, `paths.rs`. + `main.rs`, `commands.rs`, `settings_store.rs`, `clip_catalog.rs`, + `collections.rs`, `engine_rpc.rs`, `game_catalog.rs`, `paths.rs`. - `libs/capture`: Windows.Graphics.Capture display capture over D3D11. - `libs/audio`: WASAPI loopback, mic/input device capture, process-loopback, active-game detect. - `libs/encoding`: FFmpeg H.264/H.265/AAC wrappers, thumbnail gen, mux helpers, `TrackMixer`. @@ -54,7 +54,8 @@ Video path now: ```text Windows.Graphics.Capture frame -> D3D11 texture - -> CPU-readable staging texture + -> GPU downscale when supported + -> output-sized CPU-readable staging texture -> BGRA pacer buffer -> FFmpeg video encoder -> encoded video packets @@ -119,7 +120,9 @@ Active Game detect = best-effort. Use fullscreen/foreground/audio signals + conf UI use system WebView2 window thru Tauri v2. This exception apply only to `app/desktop-ui`; record engine stay native, no embed browser runtime. -Tauri host run loopback HTTP server, navigate WebView to `http://127.0.0.1:/`. Keep normal frontend `fetch()`, media, thumbnail, SSE routes, no rewrite components to Tauri `invoke()`. +The host serves the bundled Vite frontend. Operations use Tauri invoke commands +and events. The recorder JSON-RPC endpoint is separate from frontend delivery. +Media access is checked against the current configured roots. ## Runtime Paths @@ -140,8 +143,6 @@ GPU texture -> CPU staging -> BGRA vector -> sws_scale/color conversion Priority perf work: -1. GPU downscale before CPU readback. -2. Output-sized staging texture. -3. Explicit color range/matrix in CPU path. -4. D3D11/NV12 hardware encoder path. -5. AVPacket lifetime/ref-counting improve in mux path. \ No newline at end of file +GPU downscale and output-sized staging already exist with a native-size fallback. +Remaining directions are explicit color range/matrix, GPU-resident D3D11/NV12 +encoding and fewer packet copies. Measure queue pressure and disk latency first. \ No newline at end of file diff --git a/docs/superpowers/plans/2026-10-09-audit-errors.md b/docs/superpowers/plans/2026-10-09-audit-errors.md new file mode 100644 index 0000000..66dba71 --- /dev/null +++ b/docs/superpowers/plans/2026-10-09-audit-errors.md @@ -0,0 +1,23 @@ +# Audit corrections implementation plan + +**Goal:** Implement the user-approved modifications from the complete Monolith audit in one English pull request. + +**Baseline:** main 2e8c4ec1616215344b968a5f09a004cf9df6d494. + +**Design:** Preserve the native engine, Tauri sidecars, screenshot-based frontend and module boundaries. Keep media mutations in the engine. Use persistent catalog/clip identities, bounded owned workers, session-owned bookmarks, recoverable file mutations and authenticated updater metadata. Do not add unrelated features or heavy dependencies. + +## Tasks + +- [ ] Engine M01-M08, S04, F04: start order, common clock, WGC target, deferred reload, owned asynchronous writing/lifecycle, device recovery, disk session cleanup, visible failures and session bookmarks. +- [ ] Storage S01-S03, S06-S07, S10: validated paths, serialized recoverable trim, conservative reconciliation, active-writer exclusion and first-request deadline. +- [ ] Host S05, S08-S09, Q02-Q03: immutable membership identities, nondestructive reads, engine-only media writes, current-root checked media access, lightweight membership query. +- [ ] Frontend F01-F03, F05-F12: serialized settings and close flush, identity-based selection, editable-field shortcut guards, thumbnail/collection/favorite refresh, bounded probes, accessibility and fullscreen state. Expose audio-track API limits truthfully. +- [ ] Updater U01-U10: producer/consumer schema compatibility, signed component/version/digest/size, streaming verification, real process exit/readiness, stable recovery entry, cancellation and state ordering, build quoting and strict Stream Deck responses. +- [ ] Q01, Q04-Q05: bounded asynchronous runtime-rotated logs, focused responsibility extraction, current architecture/test documentation. +- [ ] Integration: native suites, Rust suite and Windows cross-check, frontend builds/browser tests, Stream Deck tests, PowerShell producer/consumer, text/whitespace checks. +- [ ] Independent review: fix concrete issues and rerun affected tests. +- [ ] Publish: durable branch checkpoints, one PR, verify CI. Keep Windows hardware/WebView2/clean-install gaps explicit. + +## Review focus + +Slow disk and shutdown; interrupted trim and competing mutations; settings save failures and out-of-order responses; catalog/root/clip identity changes; optional audio recovery; first upgrade from the old updater. Do not equate a portable passing suite with Windows runtime certification. diff --git a/libs/recording/bounded_worker.h b/libs/recording/bounded_worker.h new file mode 100644 index 0000000..bc5fce9 --- /dev/null +++ b/libs/recording/bounded_worker.h @@ -0,0 +1,58 @@ +#pragma once +#include +#include +#include +#include +#include +#include +#include +namespace recording { +class BoundedWorker { + struct Job { std::function run; size_t bytes; }; + std::mutex mutex_; + std::condition_variable changed_; + std::deque jobs_; + size_t max_jobs_, max_bytes_, bytes_ = 0; + bool active_ = false, closing_ = false; + std::function error_; + std::thread thread_; + void run() { + std::unique_lock lock(mutex_); + for (;;) { + changed_.wait(lock, [&] { return closing_ || !jobs_.empty(); }); + if (jobs_.empty()) break; + auto job = std::move(jobs_.front()); + jobs_.pop_front(); bytes_ -= job.bytes; active_ = true; + lock.unlock(); + try { job.run(); } catch (...) { try { if (error_) error_(); } catch (...) {} } + lock.lock(); active_ = false; changed_.notify_all(); + } + } +public: + BoundedWorker(size_t max_jobs, size_t max_bytes, std::function error = {}) + : max_jobs_(max_jobs), max_bytes_(max_bytes), error_(std::move(error)), + thread_([this] { run(); }) {} + ~BoundedWorker() { close(); } + BoundedWorker(const BoundedWorker&) = delete; + BoundedWorker& operator=(const BoundedWorker&) = delete; + bool submit(std::function run, size_t bytes = 0) { + std::lock_guard lock(mutex_); + if (closing_ || jobs_.size() >= max_jobs_ || bytes > max_bytes_ - bytes_) return false; + jobs_.push_back({std::move(run), bytes}); bytes_ += bytes; + changed_.notify_one(); return true; + } + bool submit_control(std::function run) { + std::lock_guard lock(mutex_); + if (closing_ || jobs_.size() >= max_jobs_ + 1) return false; + jobs_.push_back({std::move(run), 0}); changed_.notify_one(); return true; + } + void drain() { + std::unique_lock lock(mutex_); + changed_.wait(lock, [&] { return jobs_.empty() && !active_; }); + } + void close() { + { std::lock_guard lock(mutex_); closing_ = true; changed_.notify_all(); } + if (thread_.joinable()) thread_.join(); + } +}; +} diff --git a/libs/recording/media_control.h b/libs/recording/media_control.h new file mode 100644 index 0000000..912889d --- /dev/null +++ b/libs/recording/media_control.h @@ -0,0 +1,56 @@ +#pragma once +#include +#include +#include +#include +#include +#include +namespace recording { +class SessionEpoch { + std::atomic value_{0}; +public: + uint64_t begin() { return value_.fetch_add(1) + 1; } + uint64_t current() const { return value_.load(); } + bool accepts(uint64_t value) const { return value == current(); } +}; +template +bool target_changed(Target opened, Target desired) { return opened != desired; } +template +bool start_with_media(Start start, Media media, Rollback rollback) { + if (!start()) return false; + if (media()) return true; + rollback(); return false; +} +class PendingRestart { + bool pending_ = false; +public: + void request(bool changed) { pending_ = pending_ || changed; } + bool take(bool recording) { + if (recording) return false; + return std::exchange(pending_, false); + } +}; +template +class SessionBatch { +public: + struct Batch { uint64_t id = 0; std::vector items; }; +private: + std::mutex mutex_; + uint64_t next_ = 0; + Batch current_; +public: + void begin() { std::lock_guard lock(mutex_); current_ = {++next_, {}}; } + uint64_t id() { std::lock_guard lock(mutex_); return current_.id; } + bool add(Item item, uint64_t expected = 0) { + std::lock_guard lock(mutex_); + if (!current_.id || current_.items.size() >= 4096 || + (expected && expected != current_.id)) return false; + current_.items.push_back(std::move(item)); return true; + } + Batch finish() { std::lock_guard lock(mutex_); return std::exchange(current_, {}); } +}; +// WASAPI QPC positions are expressed in 100 ns units. +inline int64_t capture_time_us(int64_t position_100ns, int64_t origin_100ns) { + return std::max(0, (position_100ns - origin_100ns) / 10); +} +} diff --git a/tests/phase1/CMakeLists.txt b/tests/phase1/CMakeLists.txt index ee940c3..ae07d9d 100644 --- a/tests/phase1/CMakeLists.txt +++ b/tests/phase1/CMakeLists.txt @@ -23,3 +23,12 @@ endif() add_executable(pcm_input_test pcm_input_test.cpp) target_include_directories(pcm_input_test PRIVATE ../../libs) add_test(NAME pcm_input COMMAND pcm_input_test) + +find_package(Threads REQUIRED) +add_executable(media_control_test media_control_test.cpp) +target_include_directories(media_control_test PRIVATE ../../libs) +add_test(NAME media_control COMMAND media_control_test) +add_executable(bounded_worker_test bounded_worker_test.cpp) +target_include_directories(bounded_worker_test PRIVATE ../../libs) +target_link_libraries(bounded_worker_test PRIVATE Threads::Threads) +add_test(NAME bounded_worker COMMAND bounded_worker_test) diff --git a/tests/phase1/bounded_worker_test.cpp b/tests/phase1/bounded_worker_test.cpp new file mode 100644 index 0000000..98340e4 --- /dev/null +++ b/tests/phase1/bounded_worker_test.cpp @@ -0,0 +1,35 @@ +#include +#include +#include +#include +#include +int main() { + std::atomic errors{0}; + recording::BoundedWorker worker(2, 10, [&] { ++errors; }); + std::promise entered, release; + auto wait = release.get_future().share(); + assert(worker.submit([&] { entered.set_value(); wait.wait(); }, 1)); + entered.get_future().wait(); + std::vector order; + assert(worker.submit([&] { order.push_back(1); }, 6)); + assert(!worker.submit([] {}, 5)); + assert(worker.submit([&] { order.push_back(2); }, 4)); + assert(!worker.submit([] {}, 0)); + assert(worker.submit_control([&] { order.push_back(9); })); + release.set_value(); worker.drain(); + assert((order == std::vector{1, 2, 9})); + assert(worker.submit([] { throw 1; })); worker.drain(); assert(errors == 1); + assert(worker.submit([&] { order.push_back(3); })); worker.close(); + assert(order.back() == 3 && !worker.submit([] {})); + recording::BoundedWorker producer(4, 10), control(1, 0); + std::promise slow_entered, slow_release, complete; + auto slow_wait = slow_release.get_future().share(), completed = complete.get_future().share(); + std::atomic packets{0}; + assert(producer.submit([&] { slow_entered.set_value(); slow_wait.wait(); ++packets; }, 5)); + slow_entered.get_future().wait(); assert(producer.submit([&] { ++packets; }, 5)); + assert(control.submit([&] { producer.drain(); complete.set_value(); })); + assert(completed.wait_for(std::chrono::milliseconds(0)) == std::future_status::timeout); + slow_release.set_value(); + assert(completed.wait_for(std::chrono::seconds(2)) == std::future_status::ready); + assert(packets == 2); control.close(); producer.close(); +} diff --git a/tests/phase1/media_control_test.cpp b/tests/phase1/media_control_test.cpp new file mode 100644 index 0000000..ae462e1 --- /dev/null +++ b/tests/phase1/media_control_test.cpp @@ -0,0 +1,32 @@ +#include +#include +#include +#include +int main() { + recording::SessionEpoch epoch; + const auto old = epoch.begin(), next = epoch.begin(); + assert(!epoch.accepts(old) && epoch.accepts(next)); + assert(recording::target_changed(0, 10)); + assert(recording::target_changed(10, 20)); + assert(!recording::target_changed(20, 20)); + bool recording = false, media = false, session = false; + assert(recording::start_with_media([&] { recording = true; session = true; return true; }, + [&] { assert(session); media = recording; return media; }, [&] { recording = false; })); + assert(recording && media); + recording = false; + assert(!recording::start_with_media([&] { recording = true; return true; }, + [] { return false; }, [&] { recording = false; })); + assert(!recording); + recording::PendingRestart pending; + pending.request(true); assert(!pending.take(true)); + pending.request(false); assert(pending.take(false)); assert(!pending.take(false)); + recording::SessionBatch batch; + batch.begin(); const auto aid = batch.id(); assert(batch.add("A")); + auto a = batch.finish(); assert(!batch.add("late A")); + batch.begin(); assert(!batch.add("stale A", aid)); assert(batch.add("B")); + auto b = batch.finish(); + assert(a.id != b.id && a.items == std::vector{"A"}); + assert(b.items == std::vector{"B"}); + assert(recording::capture_time_us(6000001000, 1000000000) == 500000100); + assert(recording::capture_time_us(999999999, 1000000000) == 0); +} From 3b77da296507f6f68b0888efeb9da9f3158b8d0a Mon Sep 17 00:00:00 2001 From: fraa2a Date: Fri, 9 Oct 2026 13:15:22 +0200 Subject: [PATCH 02/14] fix: checkpoint reconstructed media, UI, storage host and updater corrections --- .github/workflows/core-tests.yml | 2 + .github/workflows/windows-ci.yml | 4 + app/desktop-ui/package.json | 2 +- .../src-tauri/capabilities/default.json | 3 +- app/desktop-ui/src-tauri/src/asset_scope.rs | 11 - app/desktop-ui/src-tauri/src/clip_catalog.rs | 383 +++-------------- .../src-tauri/src/clip_mutations.rs | 123 ++++++ app/desktop-ui/src-tauri/src/collections.rs | 171 ++++---- app/desktop-ui/src-tauri/src/commands.rs | 400 ++++++++++++------ app/desktop-ui/src-tauri/src/main.rs | 58 ++- app/desktop-ui/src-tauri/src/media_assets.rs | 235 ++++++++++ app/desktop-ui/src-tauri/src/request_pool.rs | 118 ++++++ app/desktop-ui/src-tauri/tauri.conf.json | 8 +- app/desktop-ui/tests/README.md | 8 + app/desktop-ui/tests/audit.mjs | 250 +++++++++++ app/desktop-ui/tests/ui.mjs | 6 +- app/desktop-ui/ui/src/app.tsx | 30 +- .../ui/src/home/audio-track-notice.tsx | 10 + app/desktop-ui/ui/src/home/clip-card.tsx | 193 +++++---- .../ui/src/home/collection-detail.tsx | 29 +- .../ui/src/home/collection-picker.tsx | 11 +- app/desktop-ui/ui/src/home/detail-view.tsx | 14 +- app/desktop-ui/ui/src/home/fullscreen.tsx | 11 +- app/desktop-ui/ui/src/lib/api.ts | 58 ++- app/desktop-ui/ui/src/lib/media-probes.ts | 23 + app/desktop-ui/ui/src/lib/multitrack.ts | 7 +- app/desktop-ui/ui/src/lib/player.ts | 7 + app/desktop-ui/ui/src/lib/settings-api.ts | 66 ++- app/desktop-ui/ui/src/lib/window.ts | 56 ++- app/desktop-ui/ui/src/settings/controls.tsx | 35 +- .../ui/src/settings/settings-view.tsx | 66 +-- app/desktop-ui/ui/src/shell/titlebar.tsx | 54 +-- app/desktop-ui/ui/styles.css | 4 + app/recorder/src/updater.cpp | 5 + app/updater/src-tauri/Cargo.toml | 2 +- app/updater/src-tauri/src/download.rs | 146 ++++--- app/updater/src-tauri/src/engine_rpc.rs | 24 +- app/updater/src-tauri/src/install.rs | 91 ++++ app/updater/src-tauri/src/main.rs | 93 ++-- app/updater/src-tauri/src/manifest.rs | 134 ++++++ app/updater/src-tauri/src/paths.rs | 40 +- app/updater/src-tauri/src/process.rs | 228 ++++++++++ app/updater/src-tauri/src/state.rs | 47 +- app/updater/src-tauri/src/versions.rs | 8 +- app/updater/ui/src/state-stream.ts | 20 + app/updater/ui/src/updater.tsx | 15 +- build.bat | 6 +- libs/audio/audio.cpp | 48 ++- libs/audio/audio.h | 1 + libs/capture/capture.cpp | 12 + libs/disk-segments/disk_segments.cpp | 40 +- libs/disk-segments/session_directory.h | 120 ++++++ libs/encoding/encoding.cpp | 15 +- libs/encoding/encoding.h | 2 +- libs/encoding/media_ownership.h | 45 ++ libs/logging/log_writer.h | 123 ++++++ libs/logging/logging.cpp | 67 +-- libs/logging/logging.h | 2 +- libs/recording/recording.cpp | 40 +- libs/recording/recording.h | 3 + libs/replay-buffer/replay_buffer.cpp | 8 +- plugins/stream-deck/manifest.json | 2 +- plugins/stream-deck/package-lock.json | 4 +- plugins/stream-deck/package.json | 2 +- plugins/stream-deck/src/ipc-client.ts | 12 +- scripts/generate-update-manifest.ps1 | 42 +- tests/logging/CMakeLists.txt | 10 + tests/logging/log_writer_test.cpp | 66 +++ tests/logging/win32-shim/windows.h | 12 + tests/phase1/CMakeLists.txt | 4 + tests/phase1/segment_session_test.cpp | 33 ++ tests/phase2/encoding_test.cpp | 14 + tests/phase2/media_test.cpp | 15 +- tests/rust/Cargo.toml | 2 +- tests/rust/src/host_tests.rs | 103 +++++ tests/rust/src/lib.rs | 24 +- tests/rust/src/tests.rs | 39 +- tests/stream-deck/ipc-client.test.mjs | 34 +- tests/updater/build-spaces.ps1 | 35 ++ tests/updater/manifest-contract.ps1 | 39 ++ tests/updater/state-stream.test.mjs | 41 ++ 81 files changed, 3307 insertions(+), 1067 deletions(-) delete mode 100644 app/desktop-ui/src-tauri/src/asset_scope.rs create mode 100644 app/desktop-ui/src-tauri/src/clip_mutations.rs create mode 100644 app/desktop-ui/src-tauri/src/media_assets.rs create mode 100644 app/desktop-ui/src-tauri/src/request_pool.rs create mode 100644 app/desktop-ui/tests/audit.mjs create mode 100644 app/desktop-ui/ui/src/home/audio-track-notice.tsx create mode 100644 app/desktop-ui/ui/src/lib/media-probes.ts create mode 100644 app/updater/src-tauri/src/process.rs create mode 100644 app/updater/ui/src/state-stream.ts create mode 100644 libs/disk-segments/session_directory.h create mode 100644 libs/encoding/media_ownership.h create mode 100644 libs/logging/log_writer.h create mode 100644 tests/logging/CMakeLists.txt create mode 100644 tests/logging/log_writer_test.cpp create mode 100644 tests/logging/win32-shim/windows.h create mode 100644 tests/phase1/segment_session_test.cpp create mode 100644 tests/rust/src/host_tests.rs create mode 100644 tests/updater/build-spaces.ps1 create mode 100644 tests/updater/manifest-contract.ps1 create mode 100644 tests/updater/state-stream.test.mjs diff --git a/.github/workflows/core-tests.yml b/.github/workflows/core-tests.yml index 4a06e08..aa49386 100644 --- a/.github/workflows/core-tests.yml +++ b/.github/workflows/core-tests.yml @@ -40,6 +40,8 @@ jobs: npm ci --ignore-scripts --no-audit npm run build node --test ../../tests/stream-deck/ipc-client.test.mjs + - name: Test updater state ordering + run: node --experimental-strip-types --test tests/updater/state-stream.test.mjs - name: Check and build frontends run: | for app in desktop-ui updater; do diff --git a/.github/workflows/windows-ci.yml b/.github/workflows/windows-ci.yml index 91a776e..defb0ad 100644 --- a/.github/workflows/windows-ci.yml +++ b/.github/workflows/windows-ci.yml @@ -17,6 +17,10 @@ jobs: steps: - uses: actions/checkout@v4 - uses: dtolnay/rust-toolchain@stable + - run: ./tests/updater/build-spaces.ps1 + shell: powershell + - run: ./tests/updater/manifest-contract.ps1 + shell: pwsh - run: cargo test --locked --no-default-features --manifest-path tests/rust/Cargo.toml build: diff --git a/app/desktop-ui/package.json b/app/desktop-ui/package.json index 66293c3..e070b80 100644 --- a/app/desktop-ui/package.json +++ b/app/desktop-ui/package.json @@ -9,7 +9,7 @@ "dev": "vite", "tauri": "tauri", "tauri:dev": "tauri dev", - "test:ui": "node tests/ui.mjs" + "test:ui": "node tests/ui.mjs && node tests/audit.mjs" }, "dependencies": { "@preact/signals": "^1.3.0", diff --git a/app/desktop-ui/src-tauri/capabilities/default.json b/app/desktop-ui/src-tauri/capabilities/default.json index f5a83e2..f96fb28 100644 --- a/app/desktop-ui/src-tauri/capabilities/default.json +++ b/app/desktop-ui/src-tauri/capabilities/default.json @@ -13,6 +13,7 @@ "core:window:allow-start-dragging", "core:event:default", "core:window:allow-maximize", - "core:window:allow-unmaximize" + "core:window:allow-unmaximize", + "core:window:allow-destroy" ] } diff --git a/app/desktop-ui/src-tauri/src/asset_scope.rs b/app/desktop-ui/src-tauri/src/asset_scope.rs deleted file mode 100644 index ce6c78b..0000000 --- a/app/desktop-ui/src-tauri/src/asset_scope.rs +++ /dev/null @@ -1,11 +0,0 @@ -// Refresh asset permissions after output-folder changes; include .thumbs. - -use tauri::{AppHandle, Manager}; - -pub fn refresh(app: &AppHandle) { - let dirs = crate::settings_store::output_dirs(); - // recursive: true also covers each folder's .thumbs subdirectory. - let scope = app.asset_protocol_scope(); - let _ = scope.allow_directory(&dirs.clips, true); - let _ = scope.allow_directory(&dirs.recs, true); -} diff --git a/app/desktop-ui/src-tauri/src/clip_catalog.rs b/app/desktop-ui/src-tauri/src/clip_catalog.rs index eb09c46..59a0509 100644 --- a/app/desktop-ui/src-tauri/src/clip_catalog.rs +++ b/app/desktop-ui/src-tauri/src/clip_catalog.rs @@ -1,8 +1,7 @@ use crate::{game_catalog, settings_store}; -use rusqlite::{params, Connection, OpenFlags, OptionalExtension, TransactionBehavior}; +use rusqlite::{params, Connection, OpenFlags, OptionalExtension}; use serde::{Deserialize, Serialize}; use std::collections::{BTreeSet, HashMap}; -use std::fs; use std::path::{Path, PathBuf}; #[derive(Clone, Copy)] @@ -36,10 +35,13 @@ pub struct ClipFilter { pub search: Option, } -#[derive(Serialize)] +#[derive(Clone, Serialize)] pub struct Clip { pub id: i64, pub source: String, + pub catalog_uid: String, + pub clip_uid: String, + pub media_revision: i64, pub video_file: String, pub title: String, pub thumbnail_file: Option, @@ -74,34 +76,30 @@ fn media_folder(source: ClipSource) -> PathBuf { } } -// Bookmark sequences are 1-based within each clip. +fn open(source: ClipSource) -> Option { + let conn = + Connection::open_with_flags(db_path(source), OpenFlags::SQLITE_OPEN_READ_ONLY).ok()?; + conn.busy_timeout(std::time::Duration::from_millis(4000)) + .ok()?; + Some(conn) +} -const BOOKMARK_DDL: &str = "CREATE TABLE IF NOT EXISTS clip_bookmarks ( - clip_id INTEGER NOT NULL, - seq INTEGER NOT NULL, - time_seconds REAL NOT NULL, - label TEXT NOT NULL, - color TEXT NOT NULL DEFAULT '', - PRIMARY KEY (clip_id, seq))"; +#[derive(Clone)] +pub struct ClipIdentity { + pub catalog_uid: String, + pub clip_uid: String, +} -fn open(source: ClipSource, readonly: bool) -> Option { - let path = db_path(source); - if !path.is_file() { - return None; - } - let flags = if readonly { - OpenFlags::SQLITE_OPEN_READ_ONLY - } else { - OpenFlags::SQLITE_OPEN_READ_WRITE - }; - let conn = Connection::open_with_flags(path, flags).ok()?; - let _ = conn.busy_timeout(std::time::Duration::from_millis(4000)); - if !readonly { - // Ensure the bookmarks table exists once per write connection instead - // of re-running the DDL on every add_bookmark insert. - let _ = conn.execute(BOOKMARK_DDL, []); +pub fn identity(source: ClipSource, id: i64) -> Result { + let conn = open(source).ok_or_else(|| "catalog unavailable".to_string())?; + let identity = conn.query_row( + "SELECT (SELECT value FROM catalog_metadata WHERE key='catalog_uid'), clip_uid FROM clips WHERE id=?1", + params![id], |row| Ok(ClipIdentity { catalog_uid: row.get(0)?, clip_uid: row.get(1)? }), + ).map_err(|err| format!("catalog identity unavailable: {err}"))?; + if identity.catalog_uid.is_empty() || identity.clip_uid.is_empty() { + return Err("catalog identity migration required; start the recorder".into()); } - Some(conn) + Ok(identity) } fn file_size(path: &Path) -> u64 { @@ -148,10 +146,28 @@ fn clip_select_sql(conn: &Connection) -> String { } else { "NULL" }; + let uid_expr = if has_column(conn, "clips", "clip_uid") { + "clip_uid" + } else { + "''" + }; + let revision_expr = if has_column(conn, "clips", "media_revision") { + "media_revision" + } else { + "0" + }; + let catalog_uid = conn + .query_row( + "SELECT value FROM catalog_metadata WHERE key='catalog_uid'", + [], + |row| row.get::<_, String>(0), + ) + .unwrap_or_default(); + let catalog_uid = catalog_uid.replace('\'', "''"); format!( "SELECT id, video_file, thumbnail_file, created_at_utc, duration_seconds, game_process_name, game_display_name, favorite, - COALESCE(NULLIF(title, ''), 'Untitled'), {discord_expr}, {exe_path_expr} + COALESCE(NULLIF(title, ''), 'Untitled'), {discord_expr}, {exe_path_expr}, '{catalog_uid}', {uid_expr}, {revision_expr} FROM clips", ) } @@ -184,6 +200,9 @@ fn map_clip_row( Ok(Clip { id, source: source.as_str().to_string(), + catalog_uid: row.get(11)?, + clip_uid: row.get(12)?, + media_revision: row.get(13)?, video_file, title: row .get::<_, String>(8) @@ -212,7 +231,7 @@ fn map_clip_row( } fn read_source(source: ClipSource, filter: &ClipFilter) -> Vec { - let Some(conn) = open(source, true) else { + let Some(conn) = open(source) else { return Vec::new(); }; let folder = media_folder(source); @@ -336,106 +355,6 @@ pub fn distinct_hashtags() -> Vec { tags.into_iter().collect() } -fn video_file_for(conn: &Connection, id: i64) -> Result { - conn.query_row( - "SELECT video_file FROM clips WHERE id = ?1", - params![id], - |row| row.get(0), - ) - .map_err(|_| "clip not found".to_string()) -} - -pub fn set_duration(source: ClipSource, id: i64, duration: f64) -> Result<(), String> { - if !duration.is_finite() || duration <= 0.0 { - return Err("invalid duration".to_string()); - } - let Some(conn) = open(source, false) else { - return Err("catalog unavailable".to_string()); - }; - conn.execute( - "UPDATE clips SET duration_seconds = ?1 WHERE id = ?2", - params![duration, id], - ) - .map_err(|err| err.to_string())?; - if conn.changes() == 0 { - return Err("clip not found".to_string()); - } - Ok(()) -} - -fn clip_exists(conn: &Connection, id: i64) -> bool { - conn.query_row("SELECT 1 FROM clips WHERE id = ?1", params![id], |_| Ok(())) - .is_ok() -} - -fn thumb_basename_for(video_file: &str) -> String { - Path::new(video_file) - .file_stem() - .map(|stem| format!("{}.png", stem.to_string_lossy())) - .unwrap_or_else(|| "thumb.png".to_string()) -} - -pub fn set_favorite(source: ClipSource, id: i64, favorite: bool) -> Result<(), String> { - let Some(conn) = open(source, false) else { - return Err("catalog unavailable".to_string()); - }; - conn.execute( - "UPDATE clips SET favorite = ?1 WHERE id = ?2", - params![favorite as i64, id], - ) - .map_err(|err| err.to_string())?; - if conn.changes() == 0 { - return Err("clip not found".to_string()); - } - Ok(()) -} - -pub fn set_title(source: ClipSource, id: i64, title: &str) -> Result<(), String> { - let value = if title.is_empty() { "Untitled" } else { title }; - let Some(conn) = open(source, false) else { - return Err("catalog unavailable".to_string()); - }; - conn.execute( - "UPDATE clips SET title = ?1 WHERE id = ?2", - params![value, id], - ) - .map_err(|err| err.to_string())?; - if conn.changes() == 0 { - return Err("clip not found".to_string()); - } - Ok(()) -} - -pub fn add_hashtag(source: ClipSource, id: i64, tag: &str) -> Result<(), String> { - if tag.is_empty() { - return Err("empty tag".to_string()); - } - let Some(conn) = open(source, false) else { - return Err("catalog unavailable".to_string()); - }; - if !clip_exists(&conn, id) { - return Err("clip not found".to_string()); - } - conn.execute( - "INSERT OR IGNORE INTO clip_hashtags (clip_id, tag) VALUES (?1, ?2)", - params![id, tag], - ) - .map_err(|err| err.to_string())?; - Ok(()) -} - -pub fn remove_hashtag(source: ClipSource, id: i64, tag: &str) -> Result<(), String> { - let Some(conn) = open(source, false) else { - return Err("catalog unavailable".to_string()); - }; - conn.execute( - "DELETE FROM clip_hashtags WHERE clip_id = ?1 AND tag = ?2", - params![id, tag], - ) - .map_err(|err| err.to_string())?; - Ok(()) -} - #[derive(Serialize)] pub struct BookmarkRow { pub seq: i64, @@ -445,7 +364,7 @@ pub struct BookmarkRow { } pub fn list_bookmarks(source: ClipSource, id: i64) -> Result, String> { - let Some(conn) = open(source, true) else { + let Some(conn) = open(source) else { return Err("catalog unavailable".to_string()); }; let Ok(mut stmt) = conn.prepare( @@ -469,205 +388,3 @@ pub fn list_bookmarks(source: ClipSource, id: i64) -> Result, S rows.collect::, _>>() .map_err(|err| err.to_string()) } - -pub fn add_bookmark( - source: ClipSource, - id: i64, - time_seconds: f64, - label: &str, - color: &str, -) -> Result<(), String> { - if !time_seconds.is_finite() || time_seconds < 0.0 { - return Err("invalid bookmark time".to_string()); - } - let Some(mut conn) = open(source, false) else { - return Err("catalog unavailable".to_string()); - }; - let tx = conn - .transaction_with_behavior(TransactionBehavior::Immediate) - .map_err(|err| err.to_string())?; - if !clip_exists(&tx, id) { - return Err("clip not found".to_string()); - } - let next_seq: i64 = tx - .query_row( - "SELECT COALESCE(MAX(seq), 0) + 1 FROM clip_bookmarks WHERE clip_id = ?1", - params![id], - |row| row.get(0), - ) - .map_err(|err| err.to_string())?; - tx.execute( - "INSERT INTO clip_bookmarks (clip_id, seq, time_seconds, label, color) - VALUES (?1, ?2, ?3, ?4, ?5)", - params![id, next_seq, time_seconds, label, color], - ) - .map_err(|err| err.to_string())?; - tx.commit().map_err(|err| err.to_string()) -} - -pub fn update_bookmark( - source: ClipSource, - id: i64, - seq: i64, - label: &str, - color: &str, -) -> Result<(), String> { - let Some(conn) = open(source, false) else { - return Err("catalog unavailable".to_string()); - }; - conn.execute( - "UPDATE clip_bookmarks SET label = ?1, color = ?2 WHERE clip_id = ?3 AND seq = ?4", - params![label, color, id, seq], - ) - .map_err(|err| err.to_string())?; - if conn.changes() == 0 { - return Err("bookmark not found".to_string()); - } - Ok(()) -} - -pub fn remove_bookmark(source: ClipSource, id: i64, seq: i64) -> Result<(), String> { - let Some(conn) = open(source, false) else { - return Err("catalog unavailable".to_string()); - }; - conn.execute( - "DELETE FROM clip_bookmarks WHERE clip_id = ?1 AND seq = ?2", - params![id, seq], - ) - .map_err(|err| err.to_string())?; - if conn.changes() == 0 { - return Err("bookmark not found".to_string()); - } - Ok(()) -} - -pub fn remove_clip(source: ClipSource, id: i64) -> Result<(), String> { - let Some(conn) = open(source, false) else { - return Err("catalog unavailable".to_string()); - }; - let row = conn - .query_row( - "SELECT video_file, thumbnail_file FROM clips WHERE id = ?1", - params![id], - |row| Ok((row.get::<_, String>(0)?, row.get::<_, Option>(1)?)), - ) - .map_err(|_| "clip not found".to_string())?; - let (video_file, thumbnail_file) = row; - - // One transaction: a failure between the DELETEs must not strand hashtag - // or bookmark rows pointing at a deleted clip. - let tx = conn - .unchecked_transaction() - .map_err(|err| err.to_string())?; - tx.execute("DELETE FROM clip_bookmarks WHERE clip_id = ?1", params![id]) - .map_err(|err| err.to_string())?; - tx.execute("DELETE FROM clip_hashtags WHERE clip_id = ?1", params![id]) - .map_err(|err| err.to_string())?; - tx.execute("DELETE FROM clips WHERE id = ?1", params![id]) - .map_err(|err| err.to_string())?; - tx.commit().map_err(|err| err.to_string())?; - - let folder = media_folder(source); - let _ = fs::remove_file(folder.join(&video_file)); - let thumb = thumbnail_file.unwrap_or_else(|| thumb_basename_for(&video_file)); - let _ = fs::remove_file(folder.join(".thumbs").join(&thumb)); - Ok(()) -} - -pub fn rename_clip(source: ClipSource, id: i64, new_stem: &str) -> Result<(), String> { - if new_stem.is_empty() || new_stem.chars().any(|c| "\\/:*?\"<>|.".contains(c)) { - return Err("invalid clip name".to_string()); - } - let Some(conn) = open(source, false) else { - return Err("catalog unavailable".to_string()); - }; - let row = conn - .query_row( - "SELECT video_file, thumbnail_file FROM clips WHERE id = ?1", - params![id], - |row| Ok((row.get::<_, String>(0)?, row.get::<_, Option>(1)?)), - ) - .map_err(|_| "clip not found".to_string())?; - let (old_video, old_thumb) = row; - - let folder = media_folder(source); - let ext = Path::new(&old_video) - .extension() - .map(|e| e.to_string_lossy().to_string()) - .unwrap_or_default(); - let new_video = if ext.is_empty() { - new_stem.to_string() - } else { - format!("{new_stem}.{ext}") - }; - let new_thumb = format!("{new_stem}.png"); - - if folder.join(&new_video).is_file() { - return Err("a clip with that name already exists".to_string()); - } - - fs::rename(folder.join(&old_video), folder.join(&new_video)) - .map_err(|_| "could not rename video file".to_string())?; - - let old_thumb_name = old_thumb.unwrap_or_else(|| thumb_basename_for(&old_video)); - let thumb_renamed = fs::rename( - folder.join(".thumbs").join(&old_thumb_name), - folder.join(".thumbs").join(&new_thumb), - ) - .is_ok(); - - if let Err(err) = conn.execute( - "UPDATE clips SET video_file = ?1, thumbnail_file = ?2 WHERE id = ?3", - params![ - new_video, - if thumb_renamed { - Some(&new_thumb) - } else { - None - }, - id - ], - ) { - // Restore the prior filename if the catalog update fails. - let _ = fs::rename(folder.join(&new_video), folder.join(&old_video)); - if thumb_renamed { - let _ = fs::rename( - folder.join(".thumbs").join(&new_thumb), - folder.join(".thumbs").join(&old_thumb_name), - ); - } - return Err(err.to_string()); - } - Ok(()) -} - -pub fn save_thumbnail_capture(source: ClipSource, id: i64, png: &[u8]) -> Result { - if png.is_empty() || png.len() > 8 * 1024 * 1024 { - return Err("invalid thumbnail".to_string()); - } - if !png.starts_with(b"\x89PNG\r\n\x1a\n") { - return Err("thumbnail must be png".to_string()); - } - let Some(conn) = open(source, false) else { - return Err("catalog unavailable".to_string()); - }; - let video_file = video_file_for(&conn, id)?; - let stem = Path::new(&video_file) - .file_stem() - .map(|s| s.to_string_lossy().to_string()) - .filter(|s| !s.is_empty()) - .ok_or_else(|| "invalid video name".to_string())?; - let thumb_file = format!("{stem}.png"); - let folder = media_folder(source).join(".thumbs"); - fs::create_dir_all(&folder).map_err(|err| err.to_string())?; - fs::write(folder.join(&thumb_file), png).map_err(|err| err.to_string())?; - conn.execute( - "UPDATE clips SET thumbnail_file = ?1 WHERE id = ?2", - params![thumb_file, id], - ) - .map_err(|err| err.to_string())?; - if conn.changes() == 0 { - return Err("clip not found".to_string()); - } - Ok(thumb_file) -} diff --git a/app/desktop-ui/src-tauri/src/clip_mutations.rs b/app/desktop-ui/src-tauri/src/clip_mutations.rs new file mode 100644 index 0000000..e1b97f7 --- /dev/null +++ b/app/desktop-ui/src-tauri/src/clip_mutations.rs @@ -0,0 +1,123 @@ +use base64::{engine::general_purpose, Engine as _}; +use serde_json::Value; +use std::{ + fs, + io::Write, + path::{Path, PathBuf}, +}; + +pub fn send(method: &str, params: Value) -> Result<(), String> { + let bytes = serde_json::to_vec(¶ms).map_err(|err| err.to_string())?; + if bytes.len() > 60 * 1024 { + return Err("clip request too large".into()); + } + let response = crate::engine_rpc::mutate_clip(method, params); + if response.get("ok").and_then(Value::as_bool) == Some(true) { + Ok(()) + } else { + Err(response + .get("error") + .and_then(Value::as_str) + .unwrap_or("engine error") + .to_string()) + } +} + +fn stage(root: &Path, data_url: &str) -> Result<(String, PathBuf), String> { + if data_url.len() > 12 * 1024 * 1024 { + return Err("thumbnail too large".into()); + } + let encoded = data_url + .strip_prefix("data:image/png;base64,") + .ok_or_else(|| "thumbnail must be png".to_string())?; + let png = general_purpose::STANDARD + .decode(encoded) + .map_err(|_| "bad thumbnail data".to_string())?; + if png.len() > 8 * 1024 * 1024 || !png.starts_with(b"\x89PNG\r\n\x1a\n") { + return Err("invalid png thumbnail".into()); + } + fs::create_dir_all(root).map_err(|err| err.to_string())?; + if let Ok(entries) = fs::read_dir(root) { + for entry in entries.take(128).flatten() { + let name = entry.file_name().to_string_lossy().into_owned(); + if name.len() == 36 + && name.ends_with(".png") + && name[..32].bytes().all(|c| c.is_ascii_hexdigit()) + { + if entry + .metadata() + .ok() + .and_then(|meta| meta.modified().ok()) + .and_then(|time| time.elapsed().ok()) + .is_some_and(|age| age.as_secs() > 86400) + { + let _ = fs::remove_file(entry.path()); + } + } + } + } + let random = rusqlite::Connection::open_in_memory().map_err(|err| err.to_string())?; + let token: String = random + .query_row("SELECT lower(hex(randomblob(16)))", [], |row| row.get(0)) + .map_err(|err| err.to_string())?; + let path = root.join(format!("{token}.png")); + let mut file = fs::OpenOptions::new() + .write(true) + .create_new(true) + .open(&path) + .map_err(|err| err.to_string())?; + if let Err(err) = file.write_all(&png).and_then(|_| file.sync_all()) { + drop(file); + let _ = fs::remove_file(&path); + return Err(err.to_string()); + } + Ok((token, path)) +} + +pub fn capture( + source: &str, + id: i64, + catalog_uid: &str, + clip_uid: &str, + media_revision: i64, + data_url: &str, +) -> Result { + let root = crate::paths::monolith_data_dir().join("thumb-upload"); + let (token, path) = stage(&root, data_url)?; + let result = send( + "clip_capture_thumb", + serde_json::json!({"source":source,"id":id,"catalog_uid":catalog_uid,"clip_uid":clip_uid,"media_revision":media_revision,"upload_token":token}), + ); + let _ = fs::remove_file(path); + result?; + crate::clip_catalog::clip_by_id( + crate::clip_catalog::ClipSource::parse(source).ok_or_else(|| "bad source".to_string())?, + id, + ) + .and_then(|clip| clip.thumbnail_file) + .ok_or_else(|| "thumbnail unavailable after capture".into()) +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn staging_bounds_validates_and_creates_unique_uploads() { + let root = std::env::temp_dir().join(format!("monolith-upload-{}", std::process::id())); + let _ = fs::remove_dir_all(&root); + let png = b"\x89PNG\r\n\x1a\nfixture"; + let encoded = format!( + "data:image/png;base64,{}", + general_purpose::STANDARD.encode(png) + ); + let (token, first) = stage(&root, &encoded).unwrap(); + assert_eq!(token.len(), 32); + assert!(token.bytes().all(|c| c.is_ascii_hexdigit())); + assert_eq!(fs::read(&first).unwrap(), png); + let (_, second) = stage(&root, &encoded).unwrap(); + assert_ne!(first, second); + assert!(stage(&root, "data:image/png;base64,bm90LXBuZw==").is_err()); + assert!(stage(&root, &"a".repeat(12 * 1024 * 1024)).is_err()); + fs::remove_dir_all(root).unwrap(); + } +} diff --git a/app/desktop-ui/src-tauri/src/collections.rs b/app/desktop-ui/src-tauri/src/collections.rs index e7811a6..1eda7aa 100644 --- a/app/desktop-ui/src-tauri/src/collections.rs +++ b/app/desktop-ui/src-tauri/src/collections.rs @@ -1,4 +1,4 @@ -// Collection members use (source, clip_id); IDs can overlap across catalogs. +// Catalog and clip identities survive row ID reuse and folder changes. use crate::clip_catalog::{self, ClipSource}; use crate::paths; @@ -17,8 +17,11 @@ CREATE TABLE IF NOT EXISTS collection_clips ( source TEXT NOT NULL, clip_id INTEGER NOT NULL, added_at_utc TEXT NOT NULL, - PRIMARY KEY (collection_id, source, clip_id) -);"; + catalog_uid TEXT NOT NULL, + clip_uid TEXT NOT NULL, + PRIMARY KEY (collection_id, source, catalog_uid, clip_uid) +); +CREATE INDEX IF NOT EXISTS collection_member_identity ON collection_clips(source,catalog_uid,clip_uid);"; fn open() -> Result { let dir = paths::monolith_data_dir(); @@ -27,6 +30,27 @@ fn open() -> Result { let _ = conn.busy_timeout(std::time::Duration::from_millis(4000)); conn.execute_batch("PRAGMA foreign_keys = ON;") .map_err(|err| err.to_string())?; + let legacy: bool = conn + .query_row( + "SELECT COUNT(*) FROM pragma_table_info('collection_clips') WHERE name='catalog_uid'", + [], + |row| row.get::<_, i64>(0), + ) + .map_err(|err| err.to_string())? + == 0; + let exists: bool = conn + .query_row( + "SELECT COUNT(*) FROM sqlite_master WHERE name='collection_clips'", + [], + |row| row.get::<_, i64>(0), + ) + .map_err(|err| err.to_string())? + != 0; + if exists && legacy { + conn.execute_batch("ALTER TABLE collection_clips RENAME TO collection_clips_legacy;") + .map_err(|err| err.to_string())?; + } + conn.execute_batch("CREATE TABLE IF NOT EXISTS collection_clips_legacy(collection_id INTEGER NOT NULL REFERENCES collections(id) ON DELETE CASCADE, source TEXT NOT NULL, clip_id INTEGER NOT NULL, added_at_utc TEXT NOT NULL, PRIMARY KEY(collection_id,source,clip_id));").map_err(|err| err.to_string())?; conn.execute_batch(DDL).map_err(|err| err.to_string())?; Ok(conn) } @@ -61,6 +85,7 @@ pub struct CollectionSummary { pub color: String, pub created_at_utc: String, pub clip_count: i64, + pub unresolved_count: i64, } pub fn list_collections() -> Result, String> { @@ -69,7 +94,9 @@ pub fn list_collections() -> Result, String> { .prepare( "SELECT c.id, c.name, c.color, c.created_at_utc, (SELECT COUNT(*) FROM collection_clips cc - WHERE cc.collection_id = c.id) AS clip_count + WHERE cc.collection_id = c.id) + + (SELECT COUNT(*) FROM collection_clips_legacy l WHERE l.collection_id=c.id) AS clip_count, + (SELECT COUNT(*) FROM collection_clips_legacy l WHERE l.collection_id=c.id) FROM collections c ORDER BY c.created_at_utc, c.id", ) .map_err(|err| err.to_string())?; @@ -81,6 +108,7 @@ pub fn list_collections() -> Result, String> { color: row.get(2)?, created_at_utc: row.get(3)?, clip_count: row.get(4)?, + unresolved_count: row.get(5)?, }) }) .map_err(|err| err.to_string())?; @@ -132,25 +160,35 @@ pub fn add_clip_to_collection( source: ClipSource, clip_id: i64, ) -> Result<(), String> { - let conn = open()?; - // Only accept clips that exist in the catalog right now. - if !clip_catalog::clips_by_ids(source, &[clip_id])?.contains_key(&clip_id) { - return Err("clip not found".to_string()); + let identity = clip_catalog::identity(source, clip_id)?; + add_clip_with_identity(collection_id, source, clip_id, identity) +} + +pub fn add_clip_with_identity( + collection_id: i64, + source: ClipSource, + clip_id: i64, + identity: clip_catalog::ClipIdentity, +) -> Result<(), String> { + let current = clip_catalog::identity(source, clip_id)?; + if current.catalog_uid != identity.catalog_uid || current.clip_uid != identity.clip_uid { + return Err("clip identity changed; refresh the library".into()); } + let conn = open()?; let exists: bool = conn .query_row( - "SELECT 1 FROM collections WHERE id = ?1", + "SELECT 1 FROM collections WHERE id=?1", params![collection_id], |_| Ok(()), ) .is_ok(); if !exists { - return Err("collection not found".to_string()); + return Err("collection not found".into()); } + conn.execute("INSERT OR IGNORE INTO collection_clips(collection_id,source,clip_id,added_at_utc,catalog_uid,clip_uid) VALUES(?1,?2,?3,?4,?5,?6)",params![collection_id,source.as_str(),clip_id,now_iso8601_utc(),identity.catalog_uid,identity.clip_uid]).map_err(|err|err.to_string())?; conn.execute( - "INSERT OR IGNORE INTO collection_clips (collection_id, source, clip_id, added_at_utc) - VALUES (?1, ?2, ?3, ?4)", - params![collection_id, source.as_str(), clip_id, now_iso8601_utc()], + "DELETE FROM collection_clips_legacy WHERE collection_id=?1 AND source=?2 AND clip_id=?3", + params![collection_id, source.as_str(), clip_id], ) .map_err(|err| err.to_string())?; Ok(()) @@ -160,79 +198,68 @@ pub fn remove_clip_from_collection( collection_id: i64, source: ClipSource, clip_id: i64, +) -> Result<(), String> { + let identity = clip_catalog::identity(source, clip_id)?; + remove_clip_with_identity(collection_id, source, identity) +} + +pub fn remove_clip_with_identity( + collection_id: i64, + source: ClipSource, + identity: clip_catalog::ClipIdentity, ) -> Result<(), String> { let conn = open()?; - conn.execute( - "DELETE FROM collection_clips WHERE collection_id = ?1 AND source = ?2 AND clip_id = ?3", - params![collection_id, source.as_str(), clip_id], - ) - .map_err(|err| err.to_string())?; + conn.execute("DELETE FROM collection_clips WHERE collection_id=?1 AND source=?2 AND catalog_uid=?3 AND clip_uid=?4",params![collection_id,source.as_str(),identity.catalog_uid,identity.clip_uid]).map_err(|err|err.to_string())?; Ok(()) } -// Prune absent clips only after all required catalogs have been read. -pub fn collection_clips(collection_id: i64) -> Result, String> { +pub fn collection_memberships(source: ClipSource, id: i64) -> Result, String> { + let identity = clip_catalog::identity(source, id)?; let conn = open()?; - let mut stmt = conn - .prepare( - "SELECT source, clip_id FROM collection_clips - WHERE collection_id = ?1 ORDER BY datetime(added_at_utc) DESC, clip_id DESC", + let mut stmt=conn.prepare("SELECT collection_id FROM collection_clips WHERE source=?1 AND catalog_uid=?2 AND clip_uid=?3 ORDER BY collection_id").map_err(|err|err.to_string())?; + let rows = stmt + .query_map( + params![source.as_str(), identity.catalog_uid, identity.clip_uid], + |row| row.get(0), ) .map_err(|err| err.to_string())?; - let rows = stmt + rows.collect::, _>>() + .map_err(|err| err.to_string()) +} + +pub fn collection_clips(collection_id: i64) -> Result, String> { + let conn = open()?; + let mut stmt=conn.prepare("SELECT source,clip_id,catalog_uid,clip_uid FROM collection_clips WHERE collection_id=?1 ORDER BY added_at_utc DESC,clip_id DESC").map_err(|err|err.to_string())?; + let entries = stmt .query_map(params![collection_id], |row| { - Ok((row.get::<_, String>(0)?, row.get::<_, i64>(1)?)) + Ok(( + row.get::<_, String>(0)?, + row.get::<_, i64>(1)?, + row.get::<_, String>(2)?, + row.get::<_, String>(3)?, + )) }) - .map_err(|err| err.to_string())?; - - let entries = rows + .map_err(|err| err.to_string())? .collect::, _>>() .map_err(|err| err.to_string())?; - let replay_ids: Vec<_> = entries - .iter() - .filter(|(source, _)| source == "replay") - .map(|(_, id)| *id) - .collect(); - let manual_ids: Vec<_> = entries - .iter() - .filter(|(source, _)| source == "manual") - .map(|(_, id)| *id) - .collect(); - let mut replay = if replay_ids.is_empty() { - std::collections::HashMap::new() - } else { - clip_catalog::clips_by_ids(ClipSource::Replay, &replay_ids)? - }; - let mut manual = if manual_ids.is_empty() { - std::collections::HashMap::new() - } else { - clip_catalog::clips_by_ids(ClipSource::Manual, &manual_ids)? - }; let mut clips = Vec::new(); - let mut stale = Vec::new(); - for (source, id) in entries { - let clip = match source.as_str() { - "replay" => replay.remove(&id), - "manual" => manual.remove(&id), - _ => None, - }; - if let Some(clip) = clip { - clips.push(clip); - } else { - stale.push((source, id)); + for source in [ClipSource::Replay, ClipSource::Manual] { + let members: Vec<_> = entries + .iter() + .filter(|entry| entry.0 == source.as_str()) + .collect(); + if members.is_empty() { + continue; + } + let ids: Vec<_> = members.iter().map(|entry| entry.1).collect(); + let available = clip_catalog::clips_by_ids(source, &ids)?; + for member in members { + if let Some(clip) = available.get(&member.1) { + if clip.catalog_uid == member.2 && clip.clip_uid == member.3 { + clips.push(clip.clone()); + } + } } } - drop(stmt); - // Prune only after both catalogs were read without errors. - let tx = conn - .unchecked_transaction() - .map_err(|err| err.to_string())?; - for (source, id) in stale { - tx.execute( - "DELETE FROM collection_clips WHERE collection_id = ?1 AND source = ?2 AND clip_id = ?3", - params![collection_id, source, id], - ).map_err(|err| err.to_string())?; - } - tx.commit().map_err(|err| err.to_string())?; Ok(clips) } diff --git a/app/desktop-ui/src-tauri/src/commands.rs b/app/desktop-ui/src-tauri/src/commands.rs index 551da54..64c3245 100644 --- a/app/desktop-ui/src-tauri/src/commands.rs +++ b/app/desktop-ui/src-tauri/src/commands.rs @@ -1,8 +1,8 @@ // Native Tauri commands. Run blocking disk, decode and network work through spawn_blocking. -use crate::{clip_catalog, engine_rpc, game_catalog, settings_store}; #[cfg(target_os = "windows")] use crate::exe_icon; +use crate::{clip_catalog, engine_rpc, game_catalog, settings_store}; use base64::{engine::general_purpose, Engine as _}; use clip_catalog::{Clip, ClipFilter, ClipSource}; use game_catalog::CatalogEntry; @@ -32,7 +32,6 @@ async fn blocking_result( .map_err(|err| err.to_string())? } - #[tauri::command] pub async fn list_clips(filter: ClipFilter) -> Vec { blocking(move || clip_catalog::list_clips(&filter)).await @@ -48,7 +47,6 @@ pub async fn distinct_hashtags() -> Vec { blocking(clip_catalog::distinct_hashtags).await } - #[tauri::command] pub async fn engine_status() -> Value { blocking(engine_rpc::get_status).await @@ -91,78 +89,168 @@ pub async fn set_selected_game(exe: String, pid: Option) -> Result<(), Stri } } - -#[tauri::command] -pub async fn clip_set_duration(source: String, id: i64, duration: f64) -> Result<(), String> { +async fn clip_mutation( + method: &'static str, + source: String, + id: i64, + catalog_uid: String, + clip_uid: String, + mut params: Value, +) -> Result<(), String> { let src = parse_source(&source)?; - blocking_result(move || clip_catalog::set_duration(src, id, duration)).await + params["source"] = serde_json::json!(src.as_str()); + params["id"] = serde_json::json!(id); + params["catalog_uid"] = serde_json::json!(catalog_uid); + params["clip_uid"] = serde_json::json!(clip_uid); + blocking_result(move || crate::clip_mutations::send(method, params)).await +} +#[tauri::command] +pub async fn clip_set_duration( + source: String, + id: i64, + catalog_uid: String, + clip_uid: String, + media_revision: i64, + duration: f64, +) -> Result<(), String> { + clip_mutation( + "clip_set_duration", + source, + id, + catalog_uid, + clip_uid, + serde_json::json!({"duration":duration,"media_revision":media_revision}), + ) + .await } - #[tauri::command] -pub async fn thumb_capture(source: String, id: i64, data_url: String) -> Result { +pub async fn thumb_capture( + source: String, + id: i64, + catalog_uid: String, + clip_uid: String, + media_revision: i64, + data_url: String, +) -> Result { let src = parse_source(&source)?; - let result = blocking_result(move || { - let encoded = data_url.split_once(',').map(|(_, data)| data).unwrap_or(&data_url); - let decoded = general_purpose::STANDARD - .decode(encoded.as_bytes()) - .map_err(|_| "bad thumbnail data".to_string())?; - clip_catalog::save_thumbnail_capture(src, id, &decoded) + blocking_result(move || { + crate::clip_mutations::capture( + src.as_str(), + id, + &catalog_uid, + &clip_uid, + media_revision, + &data_url, + ) }) - .await; - if let Err(err) = &result { - eprintln!("[thumb_capture] {source} clip {id} failed: {err}"); - } - result + .await } - #[tauri::command] -pub async fn clip_set_favorite(source: String, id: i64, favorite: bool) -> Result<(), String> { - let src = parse_source(&source)?; - blocking_result(move || clip_catalog::set_favorite(src, id, favorite)).await +pub async fn clip_set_favorite( + source: String, + id: i64, + catalog_uid: String, + clip_uid: String, + favorite: bool, +) -> Result<(), String> { + clip_mutation( + "clip_set_favorite", + source, + id, + catalog_uid, + clip_uid, + serde_json::json!({"favorite":favorite}), + ) + .await } - #[tauri::command] -pub async fn clip_set_title(source: String, id: i64, title: String) -> Result<(), String> { - let src = parse_source(&source)?; - blocking_result(move || clip_catalog::set_title(src, id, &title)).await +pub async fn clip_set_title( + source: String, + id: i64, + catalog_uid: String, + clip_uid: String, + title: String, +) -> Result<(), String> { + clip_mutation( + "clip_set_title", + source, + id, + catalog_uid, + clip_uid, + serde_json::json!({"title":title}), + ) + .await } - #[tauri::command] -pub async fn clip_add_hashtag(source: String, id: i64, tag: String) -> Result<(), String> { - let src = parse_source(&source)?; - blocking_result(move || clip_catalog::add_hashtag(src, id, &tag)).await +pub async fn clip_add_hashtag( + source: String, + id: i64, + catalog_uid: String, + clip_uid: String, + tag: String, +) -> Result<(), String> { + clip_mutation( + "clip_add_hashtag", + source, + id, + catalog_uid, + clip_uid, + serde_json::json!({"tag":tag}), + ) + .await } - #[tauri::command] -pub async fn clip_remove_hashtag(source: String, id: i64, tag: String) -> Result<(), String> { - let src = parse_source(&source)?; - blocking_result(move || clip_catalog::remove_hashtag(src, id, &tag)).await +pub async fn clip_remove_hashtag( + source: String, + id: i64, + catalog_uid: String, + clip_uid: String, + tag: String, +) -> Result<(), String> { + clip_mutation( + "clip_remove_hashtag", + source, + id, + catalog_uid, + clip_uid, + serde_json::json!({"tag":tag}), + ) + .await } - #[tauri::command] -pub async fn clip_rename(source: String, id: i64, new_name: String) -> Result<(), String> { - let src = parse_source(&source)?; - let params = serde_json::json!({ "source": src.as_str(), "id": id, "new_name": new_name }); - let result = blocking(move || engine_rpc::mutate_clip("clip_rename", params)).await; - if result.get("ok").and_then(Value::as_bool).unwrap_or(false) { - Ok(()) - } else { - Err(result.get("error").and_then(Value::as_str) - .unwrap_or("recorder must be running to rename clips").to_string()) - } +pub async fn clip_rename( + source: String, + id: i64, + catalog_uid: String, + clip_uid: String, + new_name: String, +) -> Result<(), String> { + clip_mutation( + "clip_rename", + source, + id, + catalog_uid, + clip_uid, + serde_json::json!({"new_name":new_name}), + ) + .await } - #[tauri::command] -pub async fn clip_delete(source: String, id: i64) -> Result<(), String> { - let src = parse_source(&source)?; - let params = serde_json::json!({ "source": src.as_str(), "id": id }); - let result = blocking(move || engine_rpc::mutate_clip("clip_delete", params)).await; - if result.get("ok").and_then(Value::as_bool).unwrap_or(false) { - Ok(()) - } else { - Err(result.get("error").and_then(Value::as_str) - .unwrap_or("recorder must be running to delete clips").to_string()) - } +pub async fn clip_delete( + source: String, + id: i64, + catalog_uid: String, + clip_uid: String, +) -> Result<(), String> { + clip_mutation( + "clip_delete", + source, + id, + catalog_uid, + clip_uid, + serde_json::json!({}), + ) + .await } // Explorer requires /select, and the path in separate arguments. @@ -213,53 +301,41 @@ pub async fn open_updater() -> Result<(), String> { .await } -// Only mutation that still needs the engine: thumbnail regeneration decodes a -// video frame via FFmpeg, which only the recorder process links against. #[tauri::command] -pub async fn clip_regen_thumb(source: String, id: i64) -> Result<(), String> { - let src = parse_source(&source)?; - let result = blocking(move || { - let params = serde_json::json!({ "source": src.as_str(), "id": id }); - engine_rpc::mutate_clip("clip_regen_thumb", params) - }) - .await; - if result.get("ok").and_then(Value::as_bool).unwrap_or(false) { - Ok(()) - } else { - let err = result - .get("error") - .and_then(Value::as_str) - .unwrap_or("engine error") - .to_string(); - eprintln!("[clip_regen_thumb] {source} clip {id} failed: {err}"); - Err(err) - } +pub async fn clip_regen_thumb( + source: String, + id: i64, + catalog_uid: String, + clip_uid: String, +) -> Result<(), String> { + clip_mutation( + "clip_regen_thumb", + source, + id, + catalog_uid, + clip_uid, + serde_json::json!({}), + ) + .await } - -// Lossless trim of a clip's video file, performed by the engine (single -// writer): the engine rewrites the file in place, retimes bookmarks and bumps -// the clip generation. `start`/`end` are seconds into the original file. #[tauri::command] -pub async fn clip_trim(source: String, id: i64, start: f64, end: f64) -> Result<(), String> { - let src = parse_source(&source)?; - let result = blocking(move || { - let params = serde_json::json!({ - "source": src.as_str(), "id": id, "start": start, "end": end, - }); - engine_rpc::mutate_clip("clip_trim", params) - }) - .await; - if result.get("ok").and_then(Value::as_bool).unwrap_or(false) { - Ok(()) - } else { - let err = result - .get("error") - .and_then(Value::as_str) - .unwrap_or("engine error") - .to_string(); - eprintln!("[clip_trim] {source} clip {id} failed: {err}"); - Err(err) - } +pub async fn clip_trim( + source: String, + id: i64, + catalog_uid: String, + clip_uid: String, + start: f64, + end: f64, +) -> Result<(), String> { + clip_mutation( + "clip_trim", + source, + id, + catalog_uid, + clip_uid, + serde_json::json!({"start":start,"end":end}), + ) + .await } // Adds a bookmark at the current position of the running manual recording. @@ -267,7 +343,8 @@ pub async fn clip_trim(source: String, id: i64, start: f64, end: f64) -> Result< // an engine error string when nothing is recording (or it is paused). #[tauri::command] pub async fn recording_add_bookmark() -> Result<(), String> { - let result = blocking(|| engine_rpc::mutate_clip("recording_add_bookmark", serde_json::json!({}))).await; + let result = + blocking(|| engine_rpc::mutate_clip("recording_add_bookmark", serde_json::json!({}))).await; if result.get("ok").and_then(Value::as_bool).unwrap_or(false) { Ok(()) } else { @@ -279,9 +356,11 @@ pub async fn recording_add_bookmark() -> Result<(), String> { } } - #[tauri::command] -pub async fn clip_list_bookmarks(source: String, id: i64) -> Result, String> { +pub async fn clip_list_bookmarks( + source: String, + id: i64, +) -> Result, String> { let src = parse_source(&source)?; blocking_result(move || clip_catalog::list_bookmarks(src, id)).await } @@ -290,33 +369,76 @@ pub async fn clip_list_bookmarks(source: String, id: i64) -> Result Result<(), String> { - let src = parse_source(&source)?; - blocking_result(move || clip_catalog::add_bookmark(src, id, time_seconds, &label, &color)).await + clip_mutation( + "clip_add_bookmark", + source, + id, + catalog_uid, + clip_uid, + serde_json::json!({"time_seconds":time_seconds,"label":label,"color":color}), + ) + .await } - #[tauri::command] pub async fn clip_update_bookmark( source: String, id: i64, + catalog_uid: String, + clip_uid: String, seq: i64, label: String, color: String, ) -> Result<(), String> { + clip_mutation( + "clip_update_bookmark", + source, + id, + catalog_uid, + clip_uid, + serde_json::json!({"seq":seq,"label":label,"color":color}), + ) + .await +} +#[tauri::command] +pub async fn clip_delete_bookmark( + source: String, + id: i64, + catalog_uid: String, + clip_uid: String, + seq: i64, +) -> Result<(), String> { + clip_mutation( + "clip_delete_bookmark", + source, + id, + catalog_uid, + clip_uid, + serde_json::json!({"seq":seq}), + ) + .await +} +#[tauri::command] +pub async fn clip_snapshot(source: String, id: i64) -> Result { let src = parse_source(&source)?; - blocking_result(move || clip_catalog::update_bookmark(src, id, seq, &label, &color)).await + blocking_result(move || { + clip_catalog::clips_by_ids(src, &[id])? + .remove(&id) + .ok_or_else(|| "clip unavailable".into()) + }) + .await } - #[tauri::command] -pub async fn clip_delete_bookmark(source: String, id: i64, seq: i64) -> Result<(), String> { +pub async fn collection_memberships(source: String, id: i64) -> Result, String> { let src = parse_source(&source)?; - blocking_result(move || clip_catalog::remove_bookmark(src, id, seq)).await + blocking_result(move || crate::collections::collection_memberships(src, id)).await } - #[tauri::command] pub async fn list_collections() -> Result, String> { blocking_result(crate::collections::list_collections).await @@ -342,9 +464,22 @@ pub async fn add_clip_to_collection( collection_id: i64, source: String, clip_id: i64, + catalog_uid: String, + clip_uid: String, ) -> Result<(), String> { let src = parse_source(&source)?; - blocking_result(move || crate::collections::add_clip_to_collection(collection_id, src, clip_id)).await + blocking_result(move || { + crate::collections::add_clip_with_identity( + collection_id, + src, + clip_id, + clip_catalog::ClipIdentity { + catalog_uid, + clip_uid, + }, + ) + }) + .await } #[tauri::command] @@ -352,9 +487,22 @@ pub async fn remove_clip_from_collection( collection_id: i64, source: String, clip_id: i64, + catalog_uid: String, + clip_uid: String, ) -> Result<(), String> { let src = parse_source(&source)?; - blocking_result(move || crate::collections::remove_clip_from_collection(collection_id, src, clip_id)).await + let _ = clip_id; + blocking_result(move || { + crate::collections::remove_clip_with_identity( + collection_id, + src, + clip_catalog::ClipIdentity { + catalog_uid, + clip_uid, + }, + ) + }) + .await } #[tauri::command] @@ -362,7 +510,6 @@ pub async fn collection_clips(collection_id: i64) -> Result, String> { blocking_result(move || crate::collections::collection_clips(collection_id)).await } - #[tauri::command] pub async fn get_settings() -> Value { blocking(|| settings_store::read_config().unwrap_or(Value::Null)).await @@ -404,21 +551,20 @@ fn find_hotkey_collision(config: &Value) -> Option { } #[tauri::command] -pub async fn save_settings(app: tauri::AppHandle, config: Value) -> Result<(), String> { +pub async fn save_settings(config: Value) -> Result<(), String> { if !config.is_object() { return Err("bad config".to_string()); } if let Some(err) = find_hotkey_collision(&config) { return Err(err); } - blocking_result(move || settings_store::write_config(&config).map_err(|err| err.to_string())).await?; + blocking_result(move || settings_store::write_config(&config).map_err(|err| err.to_string())) + .await?; if let Err(err) = blocking(engine_rpc::reload_settings).await { // Settings are saved; the engine just couldn't reload them right now // (it may not be running - it reads the new values at next start). eprintln!("engine settings reload failed: {err}"); } - // Add asset permissions for the updated output folders. - crate::asset_scope::refresh(&app); Ok(()) } @@ -436,23 +582,27 @@ pub async fn pick_folder(current: Option) -> Option { dialog = dialog.set_directory(start); } } - dialog.pick_folder().map(|p| p.to_string_lossy().to_string()) + dialog + .pick_folder() + .map(|p| p.to_string_lossy().to_string()) }) .await } - #[cfg(target_os = "windows")] #[tauri::command] pub async fn exe_icon(path: String, process: String) -> Option { blocking(move || { - exe_icon::icon_png(&path, &process) - .map(|bytes| format!("data:image/png;base64,{}", general_purpose::STANDARD.encode(bytes))) + exe_icon::icon_png(&path, &process).map(|bytes| { + format!( + "data:image/png;base64,{}", + general_purpose::STANDARD.encode(bytes) + ) + }) }) .await } - #[tauri::command] pub async fn game_catalog_map() -> BTreeMap { blocking(game_catalog::catalog_map).await diff --git a/app/desktop-ui/src-tauri/src/main.rs b/app/desktop-ui/src-tauri/src/main.rs index 56bb70c..3e0e117 100644 --- a/app/desktop-ui/src-tauri/src/main.rs +++ b/app/desktop-ui/src-tauri/src/main.rs @@ -1,15 +1,17 @@ // Tauri hosts bundled frontend assets and the native command/event bridge. #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] -mod asset_scope; mod clip_catalog; +mod clip_mutations; mod collections; mod commands; mod engine_rpc; #[cfg(target_os = "windows")] mod exe_icon; mod game_catalog; +mod media_assets; mod paths; +mod request_pool; mod settings_store; use std::thread; @@ -45,7 +47,58 @@ fn spawn_artwork_refresh() { } fn main() { + let media_pool = request_pool::Pool::new( + 4, + 128, + |(request, responder): (tauri::http::Request>, tauri::UriSchemeResponder)| { + let dirs = settings_store::output_dirs(); + let range = request + .headers() + .get("Range") + .and_then(|value| value.to_str().ok()); + let mut result = if request.method() == tauri::http::Method::HEAD { + media_assets::serve_head(request.uri().path(), range, &[dirs.clips, dirs.recs]) + } else { + media_assets::serve(request.uri().path(), range, &[dirs.clips, dirs.recs]) + }; + if request.method() != tauri::http::Method::GET + && request.method() != tauri::http::Method::HEAD + { + result.status = 405; + result.body.clear(); + } + let mut response = tauri::http::Response::builder().status(result.status); + for (name, value) in result.headers { + response = response.header(name, value); + } + match response.body(result.body) { + Ok(response) => responder.respond(response), + Err(err) => { + eprintln!("media response failed: {err}"); + responder.respond( + tauri::http::Response::builder() + .status(500) + .body(Vec::new()) + .unwrap(), + ); + } + } + }, + ) + .expect("failed to create media request workers"); tauri::Builder::default() + .register_asynchronous_uri_scheme_protocol("media", move |_context, request, responder| { + if let Err((_request, responder)) = media_pool.submit((request, responder)) { + responder.respond( + tauri::http::Response::builder() + .status(503) + .header("Retry-After", "1") + .header("Access-Control-Allow-Origin", "*") + .body(Vec::new()) + .unwrap(), + ); + } + }) .invoke_handler(tauri::generate_handler![ commands::list_clips, commands::distinct_games, @@ -75,6 +128,8 @@ fn main() { commands::add_clip_to_collection, commands::remove_clip_from_collection, commands::collection_clips, + commands::collection_memberships, + commands::clip_snapshot, commands::reveal_in_explorer, commands::open_updater, commands::get_settings, @@ -88,7 +143,6 @@ fn main() { commands::game_artwork, ]) .setup(|app| { - asset_scope::refresh(&app.handle()); spawn_clip_watch(app.handle().clone()); spawn_artwork_refresh(); diff --git a/app/desktop-ui/src-tauri/src/media_assets.rs b/app/desktop-ui/src-tauri/src/media_assets.rs new file mode 100644 index 0000000..6b65809 --- /dev/null +++ b/app/desktop-ui/src-tauri/src/media_assets.rs @@ -0,0 +1,235 @@ +use std::{ + fs, + io::{Read, Seek, SeekFrom}, + path::PathBuf, +}; + +pub struct Response { + pub status: u16, + pub headers: Vec<(String, String)>, + pub body: Vec, +} + +fn error(status: u16) -> Response { + Response { + status, + headers: vec![("Access-Control-Allow-Origin".into(), "*".into())], + body: Vec::new(), + } +} + +fn decode(path: &str) -> Option { + let bytes = path.as_bytes(); + let mut decoded = Vec::with_capacity(bytes.len()); + let mut i = 0; + while i < bytes.len() { + if bytes[i] == b'%' { + let pair = std::str::from_utf8(bytes.get(i + 1..i + 3)?).ok()?; + decoded.push(u8::from_str_radix(pair, 16).ok()?); + i += 3; + } else { + decoded.push(bytes[i]); + i += 1; + } + } + if decoded.contains(&0) { + return None; + } + let decoded = String::from_utf8(decoded).ok()?; + #[cfg(windows)] + let decoded = decoded.strip_prefix('/').unwrap_or(&decoded).to_string(); + Some(PathBuf::from(decoded)) +} + +fn serve_request(path: &str, range: Option<&str>, roots: &[PathBuf], head: bool) -> Response { + let Some(path) = decode(path) else { + return error(400); + }; + let Ok(path) = path.canonicalize() else { + return error(404); + }; + if !roots + .iter() + .filter_map(|root| root.canonicalize().ok()) + .any(|root| path.starts_with(root)) + { + return error(403); + } + let mime = match path + .extension() + .and_then(|value| value.to_str()) + .unwrap_or("") + .to_ascii_lowercase() + .as_str() + { + "png" => "image/png", + "jpg" | "jpeg" => "image/jpeg", + "mp4" => "video/mp4", + "mkv" => "video/x-matroska", + "webm" => "video/webm", + "mov" => "video/quicktime", + _ => return error(403), + }; + let Ok(mut file) = fs::File::open(&path) else { + return error(404); + }; + let Ok(meta) = file.metadata() else { + return error(500); + }; + if !meta.is_file() { + return error(404); + } + let size = meta.len(); + let (status, start, end) = if let Some(range) = range { + let invalid = || { + let mut response = error(416); + response + .headers + .push(("Content-Range".into(), format!("bytes */{size}"))); + response + }; + let Some(range) = range.strip_prefix("bytes=") else { + return invalid(); + }; + let Some((first, last)) = range.split_once('-') else { + return invalid(); + }; + if range.contains(',') || size == 0 { + return invalid(); + } + let (start, end) = if first.is_empty() { + let Ok(suffix) = last.parse::() else { + return invalid(); + }; + if suffix == 0 { + return invalid(); + } + (size.saturating_sub(suffix), size - 1) + } else { + let Ok(start) = first.parse::() else { + return invalid(); + }; + let end = if last.is_empty() { + size - 1 + } else { + let Ok(end) = last.parse::() else { + return invalid(); + }; + end.min(size - 1) + }; + (start, end) + }; + if start >= size || start > end { + return invalid(); + } + (206, start, end.min(start.saturating_add(1024 * 1024 - 1))) + } else { + if !head && size > 8 * 1024 * 1024 { + return error(413); + } + (200, 0, size.saturating_sub(1)) + }; + let len = if size == 0 { 0 } else { end - start + 1 }; + let mut body = Vec::new(); + if !head { + body.reserve(len as usize); + if file.seek(SeekFrom::Start(start)).is_err() + || file.take(len).read_to_end(&mut body).is_err() + || body.len() != len as usize + { + return error(500); + } + } + let mut headers = vec![ + ("Content-Type".into(), mime.into()), + ("Content-Length".into(), len.to_string()), + ("Accept-Ranges".into(), "bytes".into()), + ("Access-Control-Allow-Origin".into(), "*".into()), + ("Cache-Control".into(), "no-store".into()), + ]; + if status == 206 { + headers.push(( + "Content-Range".into(), + format!("bytes {start}-{end}/{size}"), + )); + } + Response { + status, + headers, + body, + } +} + +pub fn serve(path: &str, range: Option<&str>, roots: &[PathBuf]) -> Response { + serve_request(path, range, roots, false) +} +pub fn serve_head(path: &str, range: Option<&str>, roots: &[PathBuf]) -> Response { + serve_request(path, range, roots, true) +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn only_current_canonical_roots_are_readable_and_ranges_are_bounded() { + let base = std::env::temp_dir().join(format!("monolith-media-{}", std::process::id())); + let _ = fs::remove_dir_all(&base); + let a = base.join("a"); + let b = base.join("b"); + fs::create_dir_all(&a).unwrap(); + fs::create_dir_all(&b).unwrap(); + fs::write(a.join("one.png"), b"thumbnail").unwrap(); + fs::write(b.join("two.mp4"), b"0123456789").unwrap(); + let url = a.join("one.png").to_string_lossy().into_owned(); + assert_eq!(serve(&url, None, &[a.clone()]).body, b"thumbnail"); + assert_eq!(serve(&url, None, &[b.clone()]).status, 403); + assert_eq!(serve(&url, None, &[a.clone()]).status, 200); + assert_eq!( + serve( + &a.join("../b/two.mp4").to_string_lossy(), + None, + &[a.clone()] + ) + .status, + 403 + ); + let video = b.join("two.mp4").to_string_lossy().into_owned(); + let response = serve(&video, Some("bytes=2-5"), &[b.clone()]); + assert_eq!(response.status, 206); + assert_eq!(response.body, b"2345"); + assert_eq!(serve(&video, Some("bytes=-3"), &[b.clone()]).body, b"789"); + for invalid in ["bytes=20-30", "bytes=4-2", "bytes=0-1,3-4", "items=1-2"] { + assert_eq!(serve(&video, Some(invalid), &[b.clone()]).status, 416); + } + let large = b.join("large.mp4"); + fs::File::create(&large) + .unwrap() + .set_len(32 * 1024 * 1024) + .unwrap(); + assert_eq!( + serve(&large.to_string_lossy(), None, &[b.clone()]).status, + 413 + ); + let head = serve_head(&large.to_string_lossy(), None, &[b.clone()]); + assert_eq!(head.status, 200); + assert!(head.body.is_empty()); + assert!(head + .headers + .contains(&("Content-Length".into(), (32 * 1024 * 1024).to_string()))); + assert_eq!( + serve(&large.to_string_lossy(), Some("bytes=0-"), &[b.clone()]) + .body + .len(), + 1024 * 1024 + ); + #[cfg(unix)] + { + std::os::unix::fs::symlink(b.join("two.mp4"), a.join("escape.mp4")).unwrap(); + assert_eq!( + serve(&a.join("escape.mp4").to_string_lossy(), None, &[a]).status, + 403 + ); + } + fs::remove_dir_all(base).unwrap(); + } +} diff --git a/app/desktop-ui/src-tauri/src/request_pool.rs b/app/desktop-ui/src-tauri/src/request_pool.rs new file mode 100644 index 0000000..b3a9be8 --- /dev/null +++ b/app/desktop-ui/src-tauri/src/request_pool.rs @@ -0,0 +1,118 @@ +use std::{ + io, + sync::{mpsc, Arc, Mutex}, + thread, +}; + +pub struct Pool { + sender: Option>, + workers: Vec>, +} +impl Pool { + pub fn new( + workers: usize, + capacity: usize, + process: impl Fn(T) + Send + Sync + 'static, + ) -> io::Result { + if workers == 0 || capacity == 0 { + return Err(io::Error::new( + io::ErrorKind::InvalidInput, + "request pool requires workers and queue capacity", + )); + } + let (sender, receiver) = mpsc::sync_channel(capacity); + let receiver = Arc::new(Mutex::new(receiver)); + let process = Arc::new(process); + let mut pool = Self { + sender: Some(sender), + workers: Vec::with_capacity(workers), + }; + for index in 0..workers { + let receiver = receiver.clone(); + let process = process.clone(); + pool.workers.push( + thread::Builder::new() + .name(format!("media-{index}")) + .spawn(move || loop { + let job = receiver + .lock() + .unwrap_or_else(|err| err.into_inner()) + .recv(); + let Ok(job) = job else { + break; + }; + if std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| process(job))) + .is_err() + { + eprintln!("media request worker panicked"); + } + })?, + ); + } + Ok(pool) + } + pub fn submit(&self, value: T) -> Result<(), T> { + match self + .sender + .as_ref() + .expect("request pool sender missing") + .try_send(value) + { + Ok(()) => Ok(()), + Err(mpsc::TrySendError::Full(value) | mpsc::TrySendError::Disconnected(value)) => { + Err(value) + } + } + } +} +impl Drop for Pool { + fn drop(&mut self) { + self.sender.take(); + for worker in self.workers.drain(..) { + let _ = worker.join(); + } + } +} +#[cfg(test)] +mod tests { + use super::*; + use std::time::Duration; + #[test] + fn workers_and_queue_have_fixed_capacity_and_resume_after_saturation() { + let gate = Arc::new((Mutex::new(false), std::sync::Condvar::new())); + let worker_gate = gate.clone(); + let (started_tx, started_rx) = mpsc::channel(); + let (done_tx, done_rx) = mpsc::channel(); + let pool = Pool::new(2, 2, move |job: u8| { + started_tx.send(job).unwrap(); + let (lock, changed) = &*worker_gate; + let mut released = lock.lock().unwrap(); + while !*released { + released = changed.wait(released).unwrap(); + } + done_tx.send(job).unwrap(); + }) + .unwrap(); + pool.submit(1).unwrap(); + pool.submit(2).unwrap(); + started_rx.recv_timeout(Duration::from_secs(2)).unwrap(); + started_rx.recv_timeout(Duration::from_secs(2)).unwrap(); + pool.submit(3).unwrap(); + pool.submit(4).unwrap(); + assert_eq!(pool.submit(5), Err(5)); + assert!( + started_rx.try_recv().is_err(), + "only two workers may run concurrently" + ); + let (lock, changed) = &*gate; + *lock.lock().unwrap() = true; + changed.notify_all(); + for _ in 0..4 { + done_rx.recv_timeout(Duration::from_secs(2)).unwrap(); + } + pool.submit(6).unwrap(); + assert_eq!(done_rx.recv_timeout(Duration::from_secs(2)).unwrap(), 6); + drop(pool); + assert!(started_rx.recv_timeout(Duration::from_secs(2)).is_ok()); + } +} diff --git a/app/desktop-ui/src-tauri/tauri.conf.json b/app/desktop-ui/src-tauri/tauri.conf.json index 8fb133a..49d1b0b 100644 --- a/app/desktop-ui/src-tauri/tauri.conf.json +++ b/app/desktop-ui/src-tauri/tauri.conf.json @@ -12,9 +12,9 @@ "app": { "windows": [], "security": { - "csp": "default-src 'self'; img-src 'self' asset: http://asset.localhost data:; media-src 'self' asset: http://asset.localhost; connect-src 'self' ipc: http://ipc.localhost; style-src 'self' 'unsafe-inline'", + "csp": "default-src 'self'; img-src 'self' media: http://media.localhost data:; media-src 'self' media: http://media.localhost; connect-src 'self' ipc: http://ipc.localhost; style-src 'self' 'unsafe-inline'", "assetProtocol": { - "enable": true, + "enable": false, "scope": [] } } @@ -22,6 +22,8 @@ "bundle": { "active": false, "targets": "all", - "icon": ["../../../app/assets/exeicon.ico"] + "icon": [ + "../../../app/assets/exeicon.ico" + ] } } diff --git a/app/desktop-ui/tests/README.md b/app/desktop-ui/tests/README.md index d7a29e4..bdc87f7 100644 --- a/app/desktop-ui/tests/README.md +++ b/app/desktop-ui/tests/README.md @@ -26,3 +26,11 @@ Fixture thumbnails are generated test data, not shipped app content. Media requests return an empty response. This check does not validate decoding, recording devices, Windows dialogs, native window behavior or WebView2. Those still need a Windows runtime smoke test. + +The audit regressions in `audit.mjs` use port 4174. They cover settings close +paths, shared draft serialization and visible failures, stable clip identities, +focused-control keys, collection events, bounded visible metadata repair, +accessible field names, Favorites removal and fullscreen window restoration. +They also check pipeline status, compact collection membership queries and the +unsupported audio-track notice. Mock media events prove thumbnail UI updates; +they do not validate codecs, multitrack playback or native Windows behavior. diff --git a/app/desktop-ui/tests/audit.mjs b/app/desktop-ui/tests/audit.mjs new file mode 100644 index 0000000..69032c3 --- /dev/null +++ b/app/desktop-ui/tests/audit.mjs @@ -0,0 +1,250 @@ +import assert from "node:assert/strict"; +import { readFile, mkdir } from "node:fs/promises"; +import { spawn } from "node:child_process"; +import { setTimeout as delay } from "node:timers/promises"; +import { chromium } from "playwright-core"; + +const base = "http://127.0.0.1:4174"; +const seed = JSON.parse(await readFile("../../config/default-config.json", "utf8")); +const server = spawn(process.execPath, ["node_modules/vite/bin/vite.js", "preview", "--host", "127.0.0.1", "--port", "4174", "--strictPort"], { stdio: "pipe" }); +let serverError = ""; +server.stderr.on("data", (chunk) => { serverError += chunk; }); +let browser; +try { + let ready = false; + for (let attempt = 0; attempt < 100; attempt++) { + if (server.exitCode !== null) throw new Error(`Preview exited: ${serverError}`); + try { ready = (await fetch(base)).ok; } catch {} + if (ready) break; + await delay(100); + } + assert(ready, "Preview did not start"); + browser = await chromium.launch({ executablePath: process.env.UI_BROWSER_PATH || undefined, headless: true, args: ["--no-sandbox", "--disable-gpu"] }); + const page = await browser.newPage({ viewport: { width: 1920, height: 1080 } }); + if (process.env.UI_SCREENSHOT_DIR) await mkdir(process.env.UI_SCREENSHOT_DIR, { recursive: true }); + const errors = []; + page.on("pageerror", (error) => errors.push(error.message)); + await page.route("**/__fixtures__/**", async (route) => { + if (route.request().url().includes("video")) { + return route.fulfill({ status: 204 }); + } + const id = Number(route.request().url().match(/(\d+)/g)?.at(-1) ?? 0); + const hue = (id * 37) % 360; + return route.fulfill({ contentType: "image/svg+xml", body: `UI test fixture ${id}` }); + }); + await page.addInitScript((config) => { + const clips = Array.from({ length: 15 }, (_, i) => ({ id: i + 1, source: "replay", catalog_uid: "catalog-replay", clip_uid: `clip${i + 1}`, media_revision: 0, video_file: `video${i + 1}.mkv`, title: `Match ${String(i + 1).padStart(2, "0")}`, thumbnail_file: `thumb${i + 1}.svg`, video_path: `video${i + 1}.mkv`, thumbnail_path: `thumb${i + 1}.svg`, created_at_utc: "2026-10-08T10:00:00Z", duration_seconds: 30, game_process_name: "arena.exe", game_display_name: "Arena", favorite: false, hashtags: ["gameplay"], size_bytes: 12000000 })); + const collections = [{ id: 1, name: "Best moments", color: "#c4ff42", clip_count: 3, created_at_utc: "2026-10-08T10:00:00Z" }]; + let engine = { connected: true, recording: false, replay_enabled: true, capture_running: true, replay_running: true, recording_error: "", version: "1.6.2" }; + const calls = []; + window.__uiTest = { calls, config, engine, clips, collections, failCommand: false, unknown: [] }; + window.__uiTest.maximized=false; window.__uiTest.mediaLoads=0; window.__uiTest.saveDelay=0; window.__uiTest.activeSaves=0; window.__uiTest.maxSaves=0; + HTMLMediaElement.prototype.load=function(){if(this.getAttribute('src'))window.__uiTest.mediaLoads++;}; + let callback = 0; const handlers = new Map(); const listeners = new Map(); + window.__uiTest.emit = (event = "clips") => { for (const [id, listener] of listeners) if (listener.event === event) handlers.get(listener.handler)?.({event, id, payload:null}); }; + window.__TAURI_EVENT_PLUGIN_INTERNALS__ = { unregisterListener(event, id) { listeners.delete(id); } }; + window.__TAURI_INTERNALS__ = { + metadata: { currentWindow: { label: "main" }, currentWebview: { label: "main" } }, + transformCallback: (fn) => { handlers.set(++callback, fn); return callback; }, + unregisterCallback() {}, + convertFileSrc: (path) => `/__fixtures__/${path}`, + invoke: async (command, args = {}) => { + calls.push({ command, args }); + switch (command) { + case "list_clips": return structuredClone(clips.filter((clip) => (!args.filter.favorite || clip.favorite) && (!args.filter.search || clip.title.toLowerCase().includes(args.filter.search.toLowerCase())) && (!args.filter.game || args.filter.game === clip.game_display_name) && (!args.filter.hashtag || clip.hashtags.includes(args.filter.hashtag)))); + case "distinct_games": return ["Arena"]; + case "distinct_hashtags": return ["gameplay"]; + case "engine_status": return structuredClone(engine); + case "get_settings": return structuredClone(config); + case "save_settings": {window.__uiTest.activeSaves++; window.__uiTest.maxSaves=Math.max(window.__uiTest.maxSaves,window.__uiTest.activeSaves); await new Promise(r=>setTimeout(r,window.__uiTest.saveDelay)); window.__uiTest.activeSaves--; if(window.__uiTest.failSave)throw new Error('Settings unavailable'); Object.assign(config,structuredClone(args.config)); return;} + case 'plugin:window|close': window.__uiTest.emit('tauri://close-requested'); return; + case 'plugin:window|destroy': window.__uiTest.windowClosedConfig = structuredClone(config); return; + case 'plugin:window|is_maximized': return window.__uiTest.maximized; + case 'plugin:window|maximize': window.__uiTest.maximized=true; return; + case 'plugin:window|unmaximize': window.__uiTest.maximized=false; return; + case 'clip_snapshot': return structuredClone(clips.find(c=>c.source===args.source&&c.id===args.id)); + case 'thumb_capture': {const c=clips.find(c=>c.id===args.id); c.thumbnail_file='new.png'; c.thumbnail_path='new.png'; return 'new.png';} + case 'clip_regen_thumb': {const c=clips.find(c=>c.id===args.id); c.thumbnail_file='engine.png'; c.thumbnail_path='engine.png'; return;} + case 'clip_set_duration': return; + case 'collection_memberships': return [1]; + case 'reveal_in_explorer': return; + case "runtime_status": return { monitors: [{ device: "DISPLAY1", width: 1920, height: 1080, primary: true }], available_encoders: ["h264_nvenc"], input_devices: [], audio_sessions: [] }; + case "plugin:app|version": return "1.5.0"; + case "plugin:event|listen": listeners.set(callback, {event:args.event,handler:args.handler}); return callback; + case "game_catalog_map": return {}; + case "game_icon": + case "exe_icon": return null; + case "game_artwork": return { icon: null, cover: null }; + case "clip_list_bookmarks": return []; + case "clip_set_favorite": clips.find((clip) => clip.id === args.id).favorite = args.favorite; return; + case "list_collections": return structuredClone(collections); + case "collection_clips": return structuredClone(clips.slice(0, 3)); + case "create_collection": { const id = Math.max(...collections.map((c) => c.id), 0) + 1; collections.push({ id, name: args.name, color: args.color, clip_count: 0 }); return id; } + case "rename_collection": collections.find((c) => c.id === args.id).name = args.name; return; + case "delete_collection": collections.splice(collections.findIndex((c) => c.id === args.id), 1); return; + case "recorder_command": + if (window.__uiTest.failCommand) throw new Error("Recorder unavailable"); + if (args.method === "recording_start") engine.recording = true; + if (args.method === "recording_stop") engine.recording = false; + return; + default: + if (command.startsWith("plugin:window|") || command === "plugin:event|unlisten") return; + window.__uiTest.unknown.push(command); + throw new Error(`Unexpected mock command: ${command}`); + } + }, + }; + }, seed); + await page.goto(base); + async function until(fn, label) { + for (let attempt = 0; attempt < 100; attempt++) { + if (await fn()) return; + await delay(50); + } + throw new Error(`Timed out: ${label}`); + } + + + await until(async () => await page.locator(".card").count() === 15, "library"); + const failures=[]; + async function check(name,run) { + if (process.env.UI_AUDIT_FILTER && !name.includes(process.env.UI_AUDIT_FILTER)) return; + await page.reload(); + await until(async()=>await page.locator('.card').count()===15,'library'); + try {await run(); console.log(`PASS ${name}`);} catch(error) {failures.push(`${name}: ${error.message}`); console.log(`FAIL ${name}: ${error.message}`);} + } + async function settings(){await page.getByRole('button',{name:'Settings',exact:true}).click(); await until(async()=>await page.locator('[role=switch]').count()===3,'settings');} + const replay=()=>page.locator('.set-field').filter({hasText:'Replay buffer'}).getByRole('switch'); + for(const exit of ['Close settings','Escape','Library','Collections']) await check(`F01 flush ${exit}`,async()=>{ + await settings(); await replay().click(); + if(exit==='Escape')await page.keyboard.press('Escape'); else await page.getByRole('button',{name:exit,exact:true}).click(); + await delay(750); assert.equal(await page.evaluate(()=>window.__uiTest.config.replay_buffer.enabled),false); + }); + await check('F01 close window flushes pending settings',async()=>{ + await settings();await page.evaluate(()=>window.__uiTest.saveDelay=300);await replay().click(); + await page.getByRole('button',{name:'Close',exact:true}).click(); + await until(async()=>await page.evaluate(()=>!!window.__uiTest.windowClosedConfig),'window close'); + assert.equal(await page.evaluate(()=>window.__uiTest.windowClosedConfig.replay_buffer.enabled),false); + }); + await check('F01 native close waits and retains window on save error',async()=>{ + await settings();await page.evaluate(()=>{window.__uiTest.saveDelay=300;window.__uiTest.failSave=true;});await replay().click(); + await page.evaluate(()=>window.__uiTest.emit('tauri://close-requested')); + await until(async()=>(await page.locator('[role=alert]').allTextContents()).some(s=>s.includes('Settings unavailable')),'close save failure'); + assert.equal(await page.evaluate(()=>!!window.__uiTest.windowClosedConfig),false); + await page.evaluate(()=>{window.__uiTest.failSave=false;window.__uiTest.emit('tauri://close-requested');}); + await until(async()=>await page.evaluate(()=>!!window.__uiTest.windowClosedConfig),'native close retry'); + assert.equal(await page.evaluate(()=>window.__uiTest.windowClosedConfig.replay_buffer.enabled),false); + }); + await check('F02 shared serialized writes',async()=>{ + await settings(); await page.evaluate(()=>window.__uiTest.saveDelay=900); + await page.getByTitle('Capture source and mode').click(); await page.getByRole('button',{name:'Game Recording',exact:true}).click(); + await replay().click(); await delay(600); await page.getByRole('button',{name:'Close settings',exact:true}).click(); + await delay(2300); + assert.equal(await page.evaluate(()=>window.__uiTest.config.capture_mode.mode),'game_only'); + assert.equal(await page.evaluate(()=>window.__uiTest.config.replay_buffer.enabled),false); + assert.equal(await page.evaluate(()=>window.__uiTest.maxSaves),1); + }); + await check('F02 failure visible after exit',async()=>{ + await settings(); await page.evaluate(()=>window.__uiTest.failSave=true); await replay().click(); await page.getByRole('button',{name:'Close settings',exact:true}).click(); + await until(async()=>(await page.locator('[role=alert]').allTextContents()).some(s=>s.includes('Settings unavailable')),'save failure'); + }); + await check('F03 detail identity insert and removal',async()=>{ + await page.getByRole('button',{name:'Open Match 01',exact:true}).click(); + await page.evaluate(()=>{let t=window.__uiTest;t.clips.unshift({...t.clips[0],id:99,clip_uid:"clip99",title:'New clip'});t.emit();}); await delay(250); + assert.equal(await page.locator('.detail-name').textContent(),'Match 01'); + await page.evaluate(()=>{let t=window.__uiTest;t.clips.splice(t.clips.findIndex(c=>c.id===1),1);t.emit();}); + await until(async()=>await page.locator('.detail').count()===0,'removed detail'); + }); + await check('F03 reused local ID never retargets detail',async()=>{ + await page.getByRole('button',{name:'Open Match 01',exact:true}).click(); + await page.evaluate(()=>{window.__uiTest.clips[0]={...window.__uiTest.clips[0],clip_uid:'replacement',title:'Replacement'};window.__uiTest.emit();}); + await until(async()=>await page.locator('.detail').count()===0,'replaced clip identity'); + }); + await check('F03 legacy empty UIDs preserve individual clips',async()=>{ + await page.evaluate(()=>{window.__uiTest.clips.forEach(c=>{c.clip_uid='';c.catalog_uid='';});window.__uiTest.emit();}); + await page.getByRole('button',{name:'Open Match 02',exact:true}).click();assert.equal(await page.locator('.detail-name').textContent(),'Match 02'); + await page.evaluate(()=>{let t=window.__uiTest;t.clips.unshift({...t.clips[0],id:99,video_path:'other.mkv',title:'New clip'});t.emit();});await delay(250); + assert.equal(await page.locator('.detail-name').textContent(),'Match 02'); + }); + await check('F04 clipping uses running pipeline and recording errors surface',async()=>{ + assert((await page.getByTitle('Capture source and mode').textContent()).includes('Clipping')); + await page.evaluate(()=>{window.__uiTest.engine.replay_running=false;}); + await until(async()=>(await page.getByTitle('Capture source and mode').textContent()).includes('Idle'),'replay idle'); + await page.evaluate(()=>{window.__uiTest.engine.recording_error='Writer failed';}); + await until(async()=>(await page.locator('[role=alert]').allTextContents()).some(s=>s.includes('Writer failed')),'recording error'); + }); + await check('F05 arrows belong to focused text and sliders',async()=>{ + await page.getByRole('button',{name:'Open Match 01',exact:true}).click(); await page.locator('.tag-input').fill('hello'); + await page.keyboard.press('ArrowLeft'); await page.keyboard.press('ArrowRight'); + assert.equal(await page.locator('.detail-name').textContent(),'Match 01'); + await page.locator('.detail input[type=range]').first().focus(); await page.keyboard.press('ArrowRight'); + assert.equal(await page.locator('.detail-name').textContent(),'Match 01'); + }); + await check('F07 unavailable track API warns and offers file',async()=>{ + await page.getByRole('button',{name:'Open Match 01',exact:true}).click(); + await until(async()=>(await page.locator('[role=status]').allTextContents()).some(s=>s.includes('additional audio tracks')),'track capability notice'); + await page.getByRole('button',{name:'Show video file',exact:true}).click(); + assert.equal(await page.evaluate(()=>window.__uiTest.calls.filter(c=>c.command==='reveal_in_explorer').length),1); + }); + await check('F08 collection event refresh',async()=>{ + await page.getByRole('button',{name:'Collections',exact:true}).click(); await page.getByRole('button',{name:'Best moments 3 clips'}).click(); + await until(async()=>await page.locator('.card').count()===3,'collection'); + await page.evaluate(()=>{window.__uiTest.clips[0].title='Changed';window.__uiTest.emit();}); + await until(async()=>await page.getByRole('button',{name:'Open Changed',exact:true}).count()===1,'collection refresh'); + }); + await check('F09 no reads for valid catalog metadata',async()=>{await delay(100);assert.equal(await page.evaluate(()=>window.__uiTest.mediaLoads),0);}); + await check('F09 bounded visible missing-media probes',async()=>{ + await page.route('**/__fixtures__/video*', () => {}); + await page.setViewportSize({width:800,height:600}); + await page.evaluate(()=>{window.__uiTest.clips.forEach(c=>{c.thumbnail_file=null;c.thumbnail_path=null;c.duration_seconds=null;});window.__uiTest.mediaLoads=0;window.__uiTest.emit();}); + await delay(250);assert(await page.evaluate(()=>window.__uiTest.mediaLoads)<=2,'at most two concurrent repair probes'); + await page.unroute("**/__fixtures__/video*"); + await page.setViewportSize({width:1920,height:1080}); + }); + await check('F10 named switch and select',async()=>{ + await settings(); assert.equal(await page.getByRole('switch',{name:'Replay buffer',exact:true}).count(),1); + await page.getByRole('navigation',{name:'Settings pages'}).getByRole('button',{name:'Capture',exact:true}).click(); + assert.equal(await page.getByRole('combobox',{name:'Resolution',exact:true}).count(),1); + }); + await check('F11 unfavorite exits filtered list',async()=>{ + await page.locator('.card').first().getByTitle('Add to favorites').click();await page.getByRole('button',{name:'Favorites',exact:true}).click(); + await until(async()=>await page.locator('.card').count()===1,'favorites');await page.locator('.card').getByTitle('Remove from favorites').click(); + await until(async()=>await page.locator('.card').count()===0,'unfavorite'); + }); + for(const maximized of [false,true])await check(`F12 restore window ${maximized}`,async()=>{ + await page.evaluate(v=>window.__uiTest.maximized=v,maximized);await page.getByRole('button',{name:'Open Match 01',exact:true}).click(); + await page.locator('.detail').getByTitle('Fullscreen',{exact:true}).click();await delay(100);await page.keyboard.press('Escape');await delay(100); + assert.equal(await page.evaluate(()=>window.__uiTest.maximized),maximized); + }); + await check('Q03 membership reads remain compact',async()=>{ + await page.getByRole('button',{name:'Open Match 01',exact:true}).click(); + await page.locator('.detail').getByTitle('Add to collection',{exact:true}).click(); + await until(async()=>await page.getByRole('button',{name:'In collection',exact:true}).count()===1,'membership picker'); + assert.equal(await page.evaluate(()=>window.__uiTest.calls.filter(c=>c.command==='collection_clips').length),0); + assert.equal(await page.evaluate(()=>window.__uiTest.calls.filter(c=>c.command==='collection_memberships').length),1); + }); + await check('Q02 transient media saturation retries thumbnail without regeneration',async()=>{ + let requests=0; + await page.route('**/flaky.svg*',route=>{requests++;return requests===1?route.fulfill({status:503}):route.fulfill({contentType:'image/svg+xml',body:''});}); + await page.evaluate(()=>{window.__uiTest.clips[0].thumbnail_path='flaky.svg';window.__uiTest.emit();}); + await until(async()=>requests>=2&&await page.locator('.card').first().locator('.card-thumb').evaluate(img=>img.complete&&img.naturalWidth>0),'thumbnail retry'); + assert.equal(await page.evaluate(()=>window.__uiTest.calls.filter(c=>c.command==='clip_regen_thumb').length),0); + await page.unroute('**/flaky.svg*'); + }); + await check('F06 engine fallback restores missing thumbnail path',async()=>{ + await page.evaluate(()=>{const c=window.__uiTest.clips[0];c.thumbnail_file=null;c.thumbnail_path=null;c.video_file='unsupported-video.mkv';window.__uiTest.emit();}); + await until(async()=>await page.locator('.card').first().locator('.card-thumb').count()===1,'engine thumbnail'); + assert((await page.locator('.card').first().locator('.card-thumb').getAttribute('src')).includes('engine.png')); + }); + await check('F06 generated thumbnail path displayed',async()=>{ + await page.evaluate(()=>{const c=window.__uiTest.clips[0];c.thumbnail_file=null;c.thumbnail_path=null;c.duration_seconds=null;window.__uiTest.emit();}); + await until(async()=>await page.locator('.card').first().locator('.thumb-placeholder').count()===1,'missing thumb'); + await page.evaluate(()=>{ + Object.defineProperty(HTMLMediaElement.prototype,'duration',{get:()=>30});Object.defineProperty(HTMLVideoElement.prototype,'videoWidth',{get:()=>640});Object.defineProperty(HTMLVideoElement.prototype,'videoHeight',{get:()=>360});CanvasRenderingContext2D.prototype.drawImage=()=>{}; + HTMLMediaElement.prototype.load=function(){if(!this.getAttribute('src'))return;setTimeout(()=>{this.dispatchEvent(new Event('loadedmetadata'));this.dispatchEvent(new Event('loadeddata'));},10);}; + window.__uiTest.clips[0].video_file='video-new.mkv';window.__uiTest.emit(); + }); + await until(async()=>await page.locator('.card').first().locator('.card-thumb').count()===1,'generated thumbnail'); + }); + assert.equal(errors.length,0,errors.join('\n'));assert.equal(failures.length,0,failures.join('\n')); +} finally {await browser?.close();server.kill();} diff --git a/app/desktop-ui/tests/ui.mjs b/app/desktop-ui/tests/ui.mjs index d16bc8c..d872268 100644 --- a/app/desktop-ui/tests/ui.mjs +++ b/app/desktop-ui/tests/ui.mjs @@ -33,9 +33,9 @@ try { return route.fulfill({ contentType: "image/svg+xml", body: `UI test fixture ${id}` }); }); await page.addInitScript((config) => { - const clips = Array.from({ length: 15 }, (_, i) => ({ id: i + 1, source: "replay", video_file: `video${i + 1}.mkv`, title: `Match ${String(i + 1).padStart(2, "0")}`, thumbnail_file: `thumb${i + 1}.svg`, video_path: `video${i + 1}.mkv`, thumbnail_path: `thumb${i + 1}.svg`, created_at_utc: "2026-10-08T10:00:00Z", duration_seconds: 30, game_process_name: "arena.exe", game_display_name: "Arena", favorite: false, hashtags: ["gameplay"], size_bytes: 12000000 })); + const clips = Array.from({ length: 15 }, (_, i) => ({ id: i + 1, source: "replay", catalog_uid: "catalog-replay", clip_uid: `clip${i + 1}`, media_revision: 0, video_file: `video${i + 1}.mkv`, title: `Match ${String(i + 1).padStart(2, "0")}`, thumbnail_file: `thumb${i + 1}.svg`, video_path: `video${i + 1}.mkv`, thumbnail_path: `thumb${i + 1}.svg`, created_at_utc: "2026-10-08T10:00:00Z", duration_seconds: 30, game_process_name: "arena.exe", game_display_name: "Arena", favorite: false, hashtags: ["gameplay"], size_bytes: 12000000 })); const collections = [{ id: 1, name: "Best moments", color: "#c4ff42", clip_count: 3, created_at_utc: "2026-10-08T10:00:00Z" }]; - let engine = { connected: true, recording: false, replay_enabled: true, version: "1.6.2" }; + let engine = { connected: true, recording: false, replay_enabled: true, capture_running: true, replay_running: true, recording_error: "", version: "1.6.2" }; const calls = []; window.__uiTest = { calls, config, engine, clips, collections, failCommand: false, unknown: [] }; let callback = 0; @@ -113,7 +113,7 @@ try { await page.keyboard.press("Enter"); await until(async () => await page.locator(".detail").count() === 1, "keyboard clip opening"); await page.keyboard.press("Escape"); - await until(async () => await count() === 15, "detail close"); + await until(async () => await page.locator(".detail").count() === 0, "detail close"); await page.getByRole("button", { name: "Collections", exact: true }).click(); await page.getByRole("button", { name: "New collection", exact: true }).first().click(); await page.getByPlaceholder("Collection name").fill("Highlights"); diff --git a/app/desktop-ui/ui/src/app.tsx b/app/desktop-ui/ui/src/app.tsx index 161b688..3b2cd9c 100644 --- a/app/desktop-ui/ui/src/app.tsx +++ b/app/desktop-ui/ui/src/app.tsx @@ -1,7 +1,8 @@ +import { useSettingsClose } from "./lib/window.ts"; import { useCallback, useEffect, useRef, useState } from "preact/hooks"; import { collectionsApi, - type Clip, + type Clip, clipKey, clipApi, type CollectionSummary, fetchClips, @@ -37,6 +38,7 @@ const sameFilter = (a: Filter, b: Filter) => a.game === b.game && a.hashtag === b.hashtag && a.favorite === b.favorite && a.search === b.search; export function App() { + useSettingsClose(); const [clips, setClips] = useState([]); const [games, setGames] = useState([]); const [hashtags, setHashtags] = useState([]); @@ -49,7 +51,9 @@ export function App() { const [tagDialog, setTagDialog] = useState(null); const [confirmDel, setConfirmDel] = useState(null); const [fullscreen, setFullscreen] = useState<{ clip: Clip; initialTime: number } | null>(null); - const [detailIndex, setDetailIndex] = useState(null); + const [detailKey, setDetailKey] = useState(null); + const detailIndex = detailKey === null ? -1 : clips.findIndex((clip) => clipKey(clip) === detailKey); + useEffect(() => { if (detailKey !== null && detailIndex < 0) setDetailKey(null); }, [detailKey, detailIndex]); const [showSettings, setShowSettings] = useState(false); const [collectionView, setCollectionView] = useState<{ kind: "list" } | { kind: "detail"; id: number } | null>(null); const [collections, setCollections] = useState([]); @@ -82,15 +86,15 @@ export function App() { const updateClip = useCallback((next: Clip) => { setClips((items) => items.map((item) => ( - item.source === next.source && item.id === next.id ? next : item - ))); - setTagDialog((item) => item && item.source === next.source && item.id === next.id ? next : item); + clipKey(item) === clipKey(next) ? next : item + )).filter((clip) => (!filter.favorite || clip.favorite) && (!filter.game || filter.game === clip.game_display_name) && (!filter.hashtag || clip.hashtags.includes(filter.hashtag)) && (!filter.search || `${clip.title} ${clip.video_file}`.toLowerCase().includes(filter.search.toLowerCase())))); + setTagDialog((item) => item && clipKey(item) === clipKey(next) ? next : item); setFullscreen((item) => ( - item && item.clip.source === next.source && item.clip.id === next.id + item && clipKey(item.clip) === clipKey(next) ? { ...item, clip: next } : item )); - }, []); + }, [filter]); useEffect(() => { void reload(); @@ -119,7 +123,7 @@ export function App() { const openDetail = useCallback((clip: Clip) => { const i = clips.findIndex((item) => item.source === clip.source && item.id === clip.id); - if (i >= 0) setDetailIndex(i); + if (i >= 0) setDetailKey(clipKey(clips[i])); }, [clips]); // Card-level mutations (favorite, thumbnail capture, duration fix) are all @@ -171,7 +175,7 @@ export function App() { return; } setConfirmDel(null); - setDetailIndex(null); + setDetailKey(null); await reload(true); }; @@ -324,13 +328,13 @@ export function App() { /> )} - {detailIndex !== null && clips.length > 0 && ( + {detailIndex >= 0 && ( setDetailIndex(null)} + onIndex={(i) => setDetailKey(clipKey(clips[i]))} + onClose={() => setDetailKey(null)} onChanged={() => reload(true)} onClipUpdate={updateClip} onDelete={setConfirmDel} diff --git a/app/desktop-ui/ui/src/home/audio-track-notice.tsx b/app/desktop-ui/ui/src/home/audio-track-notice.tsx new file mode 100644 index 0000000..27b5337 --- /dev/null +++ b/app/desktop-ui/ui/src/home/audio-track-notice.tsx @@ -0,0 +1,10 @@ +import { type Clip, clipApi } from "../lib/api.ts"; + +export function AudioTrackNotice({ clip }: { clip: Clip }) { + return ( +
+ This player cannot select additional audio tracks. Open the video in an external player to hear all tracks. + +
+ ); +} diff --git a/app/desktop-ui/ui/src/home/clip-card.tsx b/app/desktop-ui/ui/src/home/clip-card.tsx index bbc8556..0f21617 100644 --- a/app/desktop-ui/ui/src/home/clip-card.tsx +++ b/app/desktop-ui/ui/src/home/clip-card.tsx @@ -1,6 +1,7 @@ import { memo } from "preact/compat"; import { useEffect, useRef, useState } from "preact/hooks"; -import { type Clip, clipApi, exeIconUrl, mediaUrl, thumbUrl } from "../lib/api.ts"; +import { type Clip, clipApi, clipKey, exeIconUrl, mediaUrl, thumbUrl } from "../lib/api.ts"; +import { enqueueMediaProbe } from "../lib/media-probes.ts"; import { appLabel, formatDate, formatDuration, formatSize } from "../lib/format.ts"; import { Icon } from "../shell/icons.tsx"; import { useMultiTrackAudio } from "../lib/multitrack.ts"; @@ -43,21 +44,29 @@ export const ClipCard = memo(function ClipCard( const [muted, setMuted] = useState(true); const [thumbBroken, setThumbBroken] = useState(false); const [thumbBust, setThumbBust] = useState(0); - const [localThumb, setLocalThumb] = useState(clip.thumbnail_file); + const [visible, setVisible] = useState(false); + const cardRef = useRef(null); + const latest = useRef({ clip, onChanged }); + latest.current = { clip, onChanged }; const [displayDuration, setDisplayDuration] = useState(clip.duration_seconds); const [exeIcon, setExeIcon] = useState(null); const [videoEl, setVideoEl] = useState(null); const hoverTimer = useRef(undefined); const regenTried = useRef(false); + const thumbAttempts = useRef(0); + const thumbRetryTimer = useRef | undefined>(undefined); + const thumbRepair = useRef<(() => void) | undefined>(undefined); + const mounted = useRef(true); const multitrack = useMultiTrackAudio(preview ? videoEl : null, preview ? mediaUrl(clip) : null); useEffect(() => { - setLocalThumb(clip.thumbnail_file); + clearTimeout(thumbRetryTimer.current); + thumbAttempts.current = 0; setDisplayDuration(clip.duration_seconds); setThumbBroken(false); regenTried.current = false; - }, [clip.id, clip.source, clip.thumbnail_file, clip.duration_seconds]); + }, [clipKey(clip), clip.thumbnail_path, clip.thumbnail_file, clip.duration_seconds]); // Prefer the executable icon, then cached artwork; avoid network lookup per card. useEffect(() => { @@ -77,78 +86,105 @@ export const ClipCard = memo(function ClipCard( const gameIcon = exeIcon ?? clip.game_icon_url ?? null; const hasGame = !!(clip.game_process_name || clip.game_display_name); - useEffect(() => () => clearTimeout(hoverTimer.current), []); + useEffect(() => () => { + mounted.current = false; + clearTimeout(hoverTimer.current); + clearTimeout(thumbRetryTimer.current); + thumbRepair.current?.(); + }, []); useEffect(() => { - let cancelled = false; - const needsThumb = !clip.thumbnail_file; - const video = document.createElement("video"); - video.preload = needsThumb ? "auto" : "metadata"; - video.muted = true; - video.playsInline = true; - - const finish = () => { - video.removeAttribute("src"); - video.load(); - }; - - // Use engine thumbnail generation when WebView2 cannot decode the container. - const fallbackToEngine = async () => { - if (cancelled || regenTried.current) return; - regenTried.current = true; - const res = await clipApi.regenThumb(clip); - if (!cancelled && res.ok) { - setThumbBust(Date.now()); - } - }; - - video.onloadedmetadata = async () => { - if (cancelled) return; - const duration = video.duration; - if (Number.isFinite(duration) && duration > 0 && !sameDuration(clip.duration_seconds, duration)) { - setDisplayDuration(duration); - const res = await clipApi.setDuration(clip, duration); - if (!cancelled && res.ok) onChanged({ ...clip, duration_seconds: duration }); - } - if (!needsThumb) finish(); - }; - - video.onloadeddata = async () => { - if (cancelled || !needsThumb) return; - const dataUrl = drawVideoThumb(video); - if (!dataUrl) { - await fallbackToEngine(); - finish(); - return; - } - const res = await clipApi.saveCapturedThumb(clip, dataUrl); - if (!cancelled && res.ok && typeof res.thumbnail_file === "string") { - setLocalThumb(res.thumbnail_file); - setThumbBust(Date.now()); - onChanged({ ...clip, thumbnail_file: res.thumbnail_file }); - } - finish(); - }; + const observer = new IntersectionObserver(([entry]) => setVisible(entry.isIntersecting)); + if (cardRef.current) observer.observe(cardRef.current); + return () => observer.disconnect(); + }, []); - video.onerror = () => { - // Container/codec unsupported by WebView2 (e.g. .mkv) - hand off to the - // engine regenerator instead of silently giving up. - if (needsThumb) { - void fallbackToEngine().finally(finish); - } else { - finish(); - } - }; - video.src = mediaUrl(clip); - video.load(); + async function refreshMedia(): Promise { + const updated = await clipApi.snapshot(clip); + if (!mounted.current) return; + const current = latest.current.clip; + if (clipKey(updated) !== clipKey(current) || (updated.media_revision ?? 0) < (current.media_revision ?? 0)) return; + latest.current.onChanged({ + ...current, + thumbnail_file: updated.thumbnail_file, + thumbnail_path: updated.thumbnail_path, + duration_seconds: updated.duration_seconds, + media_revision: updated.media_revision, + }); + setThumbBroken(false); + setThumbBust(Date.now()); + } + useEffect(() => { + const needsThumb = !clip.thumbnail_path; + const needsDuration = !(typeof clip.duration_seconds === "number" && Number.isFinite(clip.duration_seconds) && clip.duration_seconds > 0); + if (!visible || (!needsThumb && !needsDuration)) return; + let cancelled = false; + let finish = () => {}; + const cancelQueued = enqueueMediaProbe(() => new Promise((resolve) => { + if (cancelled) { resolve(); return; } + const video = document.createElement("video"); + video.preload = needsThumb ? "auto" : "metadata"; + video.muted = true; + video.playsInline = true; + let working = false; + const timeout = setTimeout(() => { finish(); }, 10000); + finish = () => { + clearTimeout(timeout); + video.onloadedmetadata = null; + video.onloadeddata = null; + video.onerror = null; + video.removeAttribute("src"); + video.load(); + resolve(); + }; + const repairDuration = async () => { + const duration = video.duration; + if (needsDuration && Number.isFinite(duration) && duration > 0 && !sameDuration(clip.duration_seconds, duration)) { + await clipApi.setDuration(clip, duration); + } + }; + const fallback = async () => { + if (cancelled || regenTried.current) return; + regenTried.current = true; + const result = await clipApi.regenThumb(clip); + if (!cancelled && result.ok) await refreshMedia(); + }; + video.onloadedmetadata = () => { + if (cancelled || needsThumb || working) return; + working = true; + void repairDuration().then(() => { if (!cancelled) return refreshMedia(); }).catch((error) => console.error("Metadata refresh failed", error)).finally(finish); + }; + video.onloadeddata = () => { + if (cancelled || !needsThumb || working) return; + working = true; + void (async () => { + await repairDuration(); + if (cancelled) return; + const dataUrl = drawVideoThumb(video); + if (!dataUrl) await fallback(); + else { + const result = await clipApi.saveCapturedThumb(clip, dataUrl); + if (!cancelled && result.ok) await refreshMedia(); + } + })().catch((error) => console.error("Thumbnail repair failed", error)).finally(finish); + }; + video.onerror = () => { + if (working) return; + working = true; + void (needsThumb ? fallback() : Promise.resolve()).catch((error) => console.error("Thumbnail refresh failed", error)).finally(finish); + }; + video.src = mediaUrl(clip); + video.load(); + })); return () => { cancelled = true; + cancelQueued(); finish(); }; - }, [clip.id, clip.source, clip.video_file]); + }, [visible, clipKey(clip), clip.video_file, clip.thumbnail_path, clip.duration_seconds, clip.media_revision]); - const thumb = localThumb ? thumbUrl({ ...clip, thumbnail_file: localThumb }) : null; + const thumb = thumbUrl(clip); const showPlaceholder = !thumb || thumbBroken; const thumbSrc = thumb ? `${thumb}${thumbBust ? `?v=${thumbBust}` : ""}` : null; @@ -176,19 +212,25 @@ export const ClipCard = memo(function ClipCard( setMuted(true); } - async function onThumbError() { + function onThumbError() { + if (thumbAttempts.current < 3) { + const attempt = ++thumbAttempts.current; + clearTimeout(thumbRetryTimer.current); + thumbRetryTimer.current = setTimeout(() => setThumbBust(Date.now()), attempt * 1000); + return; + } if (regenTried.current) { setThumbBroken(true); return; } regenTried.current = true; - const res = await clipApi.regenThumb(clip); - if (res.ok) { - setThumbBust(Date.now()); - onChanged(clip); - } else { - setThumbBroken(true); - } + thumbRepair.current = enqueueMediaProbe(async () => { + if (!mounted.current || !visible) return; + const result = await clipApi.regenThumb(clip); + if (!mounted.current) return; + if (result.ok) await refreshMedia(); + else setThumbBroken(true); + }); } async function toggleFavorite(e: MouseEvent) { @@ -203,6 +245,7 @@ export const ClipCard = memo(function ClipCard( return (
{ e.preventDefault(); onContextMenu(e as unknown as MouseEvent, clip); diff --git a/app/desktop-ui/ui/src/home/collection-detail.tsx b/app/desktop-ui/ui/src/home/collection-detail.tsx index 53bfc6e..f70ce05 100644 --- a/app/desktop-ui/ui/src/home/collection-detail.tsx +++ b/app/desktop-ui/ui/src/home/collection-detail.tsx @@ -1,5 +1,5 @@ import { useCallback, useEffect, useRef, useState } from "preact/hooks"; -import { type Clip, type CollectionSummary, clipApi, collectionsApi } from "../lib/api.ts"; +import { type Clip, clipKey, subscribeClips, type CollectionSummary, clipApi, collectionsApi } from "../lib/api.ts"; import { Icon } from "../shell/icons.tsx"; import { ClipCard } from "./clip-card.tsx"; import { ConfirmDialog } from "./confirm-dialog.tsx"; @@ -30,7 +30,9 @@ export function CollectionDetail({ collection, allHashtags, onBack, onChanged }: const [confirmDel, setConfirmDel] = useState(null); const [confirmRemove, setConfirmRemove] = useState(null); const [fullscreen, setFullscreen] = useState<{ clip: Clip; initialTime: number } | null>(null); - const [detailIndex, setDetailIndex] = useState(null); + const [detailKey, setDetailKey] = useState(null); + const detailIndex = detailKey === null ? -1 : clips.findIndex((clip) => clipKey(clip) === detailKey); + useEffect(() => { if (detailKey !== null && detailIndex < 0) setDetailKey(null); }, [detailKey, detailIndex]); const [renaming, setRenaming] = useState(false); const [confirmDeleteCol, setConfirmDeleteCol] = useState(false); const [busy, setBusy] = useState(false); @@ -57,13 +59,15 @@ export function CollectionDetail({ collection, allHashtags, onBack, onChanged }: return () => { ++loadId.current; }; }, [refetch]); + useEffect(() => subscribeClips(() => { void refetch(true); }), [refetch]); + const updateClip = (next: Clip) => { setClips((items) => items.map((item) => ( - item.source === next.source && item.id === next.id ? next : item + clipKey(item) === clipKey(next) ? next : item ))); - setTagDialog((item) => item && item.source === next.source && item.id === next.id ? next : item); + setTagDialog((item) => item && clipKey(item) === clipKey(next) ? next : item); setFullscreen((item) => ( - item && item.clip.source === next.source && item.clip.id === next.id + item && clipKey(item.clip) === clipKey(next) ? { ...item, clip: next } : item )); @@ -125,7 +129,7 @@ export function CollectionDetail({ collection, allHashtags, onBack, onChanged }: setBusy(false); if (res.ok) { setConfirmRemove(null); - setDetailIndex(null); + setDetailKey(null); await refetch(); onChanged(); } @@ -138,7 +142,7 @@ export function CollectionDetail({ collection, allHashtags, onBack, onChanged }: setBusy(false); if (res.ok) { setConfirmDel(null); - setDetailIndex(null); + setDetailKey(null); await refetch(); onChanged(); } @@ -171,6 +175,7 @@ export function CollectionDetail({ collection, allHashtags, onBack, onChanged }:
+ {(collection.unresolved_count ?? 0) > 0 &&

Legacy memberships need confirmation. Re-add the intended clips to restore them.

} {error &&

{error}

} {loading @@ -197,7 +202,7 @@ export function CollectionDetail({ collection, allHashtags, onBack, onChanged }: onChanged={updateClip} onContextMenu={openMenu} onFullscreen={(c, t) => setFullscreen({ clip: c, initialTime: t })} - onOpenDetail={() => setDetailIndex(i)} + onOpenDetail={() => setDetailKey(clipKey(c))} /> ))} @@ -256,13 +261,13 @@ export function CollectionDetail({ collection, allHashtags, onBack, onChanged }: /> )} - {detailIndex !== null && clips.length > 0 && ( + {detailIndex >= 0 && ( setDetailIndex(null)} + onIndex={(i) => setDetailKey(clipKey(clips[i]))} + onClose={() => setDetailKey(null)} onChanged={refetch} onClipUpdate={updateClip} onDelete={setConfirmDel} diff --git a/app/desktop-ui/ui/src/home/collection-picker.tsx b/app/desktop-ui/ui/src/home/collection-picker.tsx index 39945fd..1210ebc 100644 --- a/app/desktop-ui/ui/src/home/collection-picker.tsx +++ b/app/desktop-ui/ui/src/home/collection-picker.tsx @@ -22,15 +22,9 @@ export function CollectionPicker({ clip, onClose, onChanged }: { setLoading(true); setError(null); try { - const list = await collectionsApi.list(); - const flags = await Promise.all( - list.map(async (c) => { - const items = await collectionsApi.clips(c.id); - return items.some((item) => item.source === clip.source && item.id === clip.id); - }), - ); + const [list, ids] = await Promise.all([collectionsApi.list(), collectionsApi.memberships(clip)]); setCollections(list); - setMembership(new Set(list.filter((_, i) => flags[i]).map((c) => c.id))); + setMembership(new Set(ids)); } catch (err) { setError(String(err)); } finally { @@ -97,6 +91,7 @@ export function CollectionPicker({ clip, onClose, onChanged }: {
e.stopPropagation()}>

Add to collection

+ {collections.some((c) => (c.unresolved_count ?? 0) > 0) &&

Legacy memberships need confirmation. Re-add the intended clips to restore them.

}
{loading ? diff --git a/app/desktop-ui/ui/src/home/detail-view.tsx b/app/desktop-ui/ui/src/home/detail-view.tsx index 7e5808f..4bf512a 100644 --- a/app/desktop-ui/ui/src/home/detail-view.tsx +++ b/app/desktop-ui/ui/src/home/detail-view.tsx @@ -1,9 +1,11 @@ +import { AudioTrackNotice } from "./audio-track-notice.tsx"; +import { ownsPlayerKeys } from "../lib/player.ts"; import { useEffect, useMemo, useRef, useState } from "preact/hooks"; import { type BookmarkRow, type Clip, clipApi, mediaUrl } from "../lib/api.ts"; import { appLabel, formatDate, formatDuration, formatSize } from "../lib/format.ts"; import { Icon } from "../shell/icons.tsx"; import { useMultiTrackAudio } from "../lib/multitrack.ts"; -import { appWindow } from "../lib/window.ts"; +import { usePlayerWindow } from "../lib/window.ts"; import { FullscreenChrome } from "./fullscreen.tsx"; interface Props { @@ -236,6 +238,8 @@ export function DetailView( useEffect(() => { const onKey = (e: KeyboardEvent) => { if (editing || fsMode || editingSeq !== null) return; + if (ownsPlayerKeys(e) && e.key !== "Escape") return; + if ((e.target as HTMLElement)?.closest?.(".modal, [role=dialog], [role=alertdialog]")) return; if (trimming) { // While trimming, Esc cancels trim mode; arrow keys belong to the // focused trim handle, so don't navigate clips with them. @@ -281,12 +285,7 @@ export function DetailView( return () => { cancelled = true; }; }, [clip?.id, clip?.source]); - // Reuse the detail video element when changing fullscreen chrome. - useEffect(() => { - if (!fsMode) return; - appWindow.maximize(); - return () => { appWindow.unmaximize(); }; - }, [fsMode]); + usePlayerWindow(fsMode); if (!clip) return null; @@ -698,6 +697,7 @@ export function DetailView( )}
{actionError &&
{actionError}
} + {multitrack.unsupported && }
{clip.video_file}
diff --git a/app/desktop-ui/ui/src/home/fullscreen.tsx b/app/desktop-ui/ui/src/home/fullscreen.tsx index 5a447c8..2292ffb 100644 --- a/app/desktop-ui/ui/src/home/fullscreen.tsx +++ b/app/desktop-ui/ui/src/home/fullscreen.tsx @@ -1,8 +1,10 @@ +import { AudioTrackNotice } from "./audio-track-notice.tsx"; +import { ownsPlayerKeys } from "../lib/player.ts"; import { useEffect, useRef, useState } from "preact/hooks"; import { type Clip, mediaUrl } from "../lib/api.ts"; import { Icon } from "../shell/icons.tsx"; import { useMultiTrackAudio, type MultiTrackHandle } from "../lib/multitrack.ts"; -import { appWindow } from "../lib/window.ts"; +import { usePlayerWindow } from "../lib/window.ts"; interface Props { clip: Clip; @@ -110,6 +112,7 @@ export function FullscreenChrome( useEffect(() => { const onKey = (e: KeyboardEvent) => { + if (ownsPlayerKeys(e) && e.key !== "Escape") return; if (e.key === "Escape") { onClose(); return; } if (e.key === " " || e.key === "Spacebar") { e.preventDefault(); togglePlay(); wake(); return; } if (e.key === "ArrowLeft") { skip(-SKIP_SECONDS); wake(); return; } @@ -198,10 +201,7 @@ export function Fullscreen({ clip, initialTime = 0, onClose }: FullscreenProps) const multitrack = useMultiTrackAudio(videoEl, mediaUrl(clip)); - useEffect(() => { - appWindow.maximize(); - return () => { appWindow.unmaximize(); }; - }, []); + usePlayerWindow(true); return (
@@ -221,6 +221,7 @@ export function Fullscreen({ clip, initialTime = 0, onClose }: FullscreenProps) }} /> + {multitrack.unsupported &&
}
); } diff --git a/app/desktop-ui/ui/src/lib/api.ts b/app/desktop-ui/ui/src/lib/api.ts index 39be862..9e9c897 100644 --- a/app/desktop-ui/ui/src/lib/api.ts +++ b/app/desktop-ui/ui/src/lib/api.ts @@ -7,6 +7,9 @@ export type ClipSource = "replay" | "manual"; export interface Clip { id: number; source: ClipSource; + catalog_uid: string; + clip_uid: string; + media_revision: number; video_file: string; // User-facing display name, independent of the on-disk filename. Defaults to // "Untitled" for new clips; renaming edits this, not the file. @@ -28,6 +31,14 @@ export interface Clip { thumbnail_path: string | null; } +export function clipKey(clip: Clip): string { + return JSON.stringify([clip.source, clip.catalog_uid || clip.video_path, clip.clip_uid || `${clip.id}:${clip.created_at_utc}`]); +} + +export function clipIdentity(clip: Clip) { + return { source: clip.source, id: clip.id, catalogUid: clip.catalog_uid, clipUid: clip.clip_uid }; +} + export interface Filter { game?: string; hashtag?: string; @@ -77,28 +88,29 @@ export interface CollectionSummary { color: string; created_at_utc: string; clip_count: number; + unresolved_count?: number; } export const clipApi = { + snapshot: (c: Clip) => invoke("clip_snapshot", { source: c.source, id: c.id }), setFavorite: (c: Clip, favorite: boolean) => - ok(invoke("clip_set_favorite", { source: c.source, id: c.id, favorite })), + ok(invoke("clip_set_favorite", { ...clipIdentity(c), favorite })), addHashtag: (c: Clip, tag: string) => - ok(invoke("clip_add_hashtag", { source: c.source, id: c.id, tag })), + ok(invoke("clip_add_hashtag", { ...clipIdentity(c), tag })), removeHashtag: (c: Clip, tag: string) => - ok(invoke("clip_remove_hashtag", { source: c.source, id: c.id, tag })), + ok(invoke("clip_remove_hashtag", { ...clipIdentity(c), tag })), // Renames the on-disk file (advanced action). new_name is a stem, no extension. rename: (c: Clip, new_name: string) => - ok(invoke("clip_rename", { source: c.source, id: c.id, newName: new_name })), + ok(invoke("clip_rename", { ...clipIdentity(c), newName: new_name })), // Edits the display title only; the file on disk is untouched. setTitle: (c: Clip, title: string) => - ok(invoke("clip_set_title", { source: c.source, id: c.id, title })), + ok(invoke("clip_set_title", { ...clipIdentity(c), title })), // Asks the engine to rebuild a missing/corrupt thumbnail. - regenThumb: (c: Clip) => ok(invoke("clip_regen_thumb", { source: c.source, id: c.id })), - delete: (c: Clip) => ok(invoke("clip_delete", { source: c.source, id: c.id })), + regenThumb: (c: Clip) => ok(invoke("clip_regen_thumb", { ...clipIdentity(c) })), + delete: (c: Clip) => ok(invoke("clip_delete", { ...clipIdentity(c) })), setDuration: (c: Clip, duration: number) => - ok(invoke("clip_set_duration", { source: c.source, id: c.id, duration })), - // thumb_capture returns the thumbnail filename; keep it on the envelope so - // clip-card can update the grid row without a refetch. + ok(invoke("clip_set_duration", { ...clipIdentity(c), mediaRevision: c.media_revision, duration })), + // The card reads clip_snapshot after capture to receive the absolute path. saveCapturedThumb: async (c: Clip, dataUrl: string): Promise<{ ok: boolean; thumbnail_file?: string; @@ -106,8 +118,8 @@ export const clipApi = { }> => { try { const thumbnail_file = await invoke("thumb_capture", { - source: c.source, - id: c.id, + ...clipIdentity(c), + mediaRevision: c.media_revision, dataUrl, }); return { ok: true, thumbnail_file }; @@ -117,15 +129,15 @@ export const clipApi = { }, revealInExplorer: (c: Clip) => ok(invoke("reveal_in_explorer", { path: c.video_path })), trim: (c: Clip, start: number, end: number) => - ok(invoke("clip_trim", { source: c.source, id: c.id, start, end })), + ok(invoke("clip_trim", { ...clipIdentity(c), start, end })), listBookmarks: (c: Clip) => - invoke("clip_list_bookmarks", { source: c.source, id: c.id }), + invoke("clip_list_bookmarks", { ...clipIdentity(c) }), addBookmark: (c: Clip, timeSeconds: number, label: string, color: string) => - ok(invoke("clip_add_bookmark", { source: c.source, id: c.id, timeSeconds, label, color })), + ok(invoke("clip_add_bookmark", { ...clipIdentity(c), timeSeconds, label, color })), updateBookmark: (c: Clip, seq: number, label: string, color: string) => - ok(invoke("clip_update_bookmark", { source: c.source, id: c.id, seq, label, color })), + ok(invoke("clip_update_bookmark", { ...clipIdentity(c), seq, label, color })), deleteBookmark: (c: Clip, seq: number) => - ok(invoke("clip_delete_bookmark", { source: c.source, id: c.id, seq })), + ok(invoke("clip_delete_bookmark", { ...clipIdentity(c), seq })), recordingAddBookmark: () => ok(invoke("recording_add_bookmark")), }; @@ -134,11 +146,12 @@ export const collectionsApi = { create: (name: string, color: string) => invoke("create_collection", { name, color }), rename: (id: number, name: string) => ok(invoke("rename_collection", { id, name })), remove: (id: number) => ok(invoke("delete_collection", { id })), + memberships: (c: Clip) => invoke("collection_memberships", { source: c.source, id: c.id }), clips: (id: number) => invoke("collection_clips", { collectionId: id }), addClip: (id: number, c: Clip) => - ok(invoke("add_clip_to_collection", { collectionId: id, source: c.source, clipId: c.id })), + ok(invoke("add_clip_to_collection", { collectionId: id, source: c.source, clipId: c.id, catalogUid: c.catalog_uid, clipUid: c.clip_uid })), removeClip: (id: number, c: Clip) => - ok(invoke("remove_clip_from_collection", { collectionId: id, source: c.source, clipId: c.id })), + ok(invoke("remove_clip_from_collection", { collectionId: id, source: c.source, clipId: c.id, catalogUid: c.catalog_uid, clipUid: c.clip_uid })), }; export function subscribeClips(onChange: () => void): () => void { @@ -158,12 +171,12 @@ export function subscribeClips(onChange: () => void): () => void { } export function mediaUrl(c: Clip): string { - return convertFileSrc(c.video_path); + return convertFileSrc(c.video_path, "media"); } export function thumbUrl(c: Clip): string | null { if (!c.thumbnail_path) return null; - return convertFileSrc(c.thumbnail_path); + return convertFileSrc(c.thumbnail_path, "media"); } export interface CatalogEntry { @@ -249,6 +262,9 @@ export interface EngineStatus { recording?: boolean; paused?: boolean; replay_enabled?: boolean; + capture_running?: boolean; + replay_running?: boolean; + recording_error?: string; recording_enabled?: boolean; clip_generation?: number; // Engine component version (the interface version is separate - the two diff --git a/app/desktop-ui/ui/src/lib/media-probes.ts b/app/desktop-ui/ui/src/lib/media-probes.ts new file mode 100644 index 0000000..e3bb46d --- /dev/null +++ b/app/desktop-ui/ui/src/lib/media-probes.ts @@ -0,0 +1,23 @@ +type Probe = { run: () => Promise; cancelled: boolean }; +const pending: Probe[] = []; +let active = 0; +const LIMIT = 2; + +function drain(): void { + while (active < LIMIT && pending.length) { + const probe = pending.shift()!; + if (probe.cancelled) continue; + ++active; + void probe.run().catch((error) => console.error("Media probe failed", error)).finally(() => { + --active; + drain(); + }); + } +} + +export function enqueueMediaProbe(run: () => Promise): () => void { + const probe = { run, cancelled: false }; + pending.push(probe); + drain(); + return () => { probe.cancelled = true; }; +} diff --git a/app/desktop-ui/ui/src/lib/multitrack.ts b/app/desktop-ui/ui/src/lib/multitrack.ts index 871e8e4..794107f 100644 --- a/app/desktop-ui/ui/src/lib/multitrack.ts +++ b/app/desktop-ui/ui/src/lib/multitrack.ts @@ -1,7 +1,7 @@ // WebView2 plays the first audio track. Hidden elements select additional tracks // by fragment and follow the visible video clock; unavailable tracks are ignored. -import { useEffect, useRef } from "preact/hooks"; +import { useEffect, useRef, useState } from "preact/hooks"; const DRIFT_CORRECT_SEC = 0.15; @@ -10,6 +10,7 @@ interface ShadowTrack { } export interface MultiTrackHandle { + unsupported: boolean; setMuted: (muted: boolean) => void; setVolume: (volume: number) => void; } @@ -19,6 +20,7 @@ export function useMultiTrackAudio( video: HTMLVideoElement | null, src: string | null, ): MultiTrackHandle { + const [unsupported, setUnsupported] = useState(false); const shadowsRef = useRef([]); const mutedRef = useRef(true); const volumeRef = useRef(1); @@ -53,6 +55,7 @@ export function useMultiTrackAudio( } let cancelled = false; + setUnsupported(!(video as any).audioTracks); mutedRef.current = video.muted; volumeRef.current = video.volume; @@ -60,6 +63,7 @@ export function useMultiTrackAudio( if (cancelled) return; teardown(); const tracks = (video as any).audioTracks; + setUnsupported(!tracks); const count = tracks && typeof tracks.length === "number" ? tracks.length : 0; if (count <= 1) return; @@ -163,6 +167,7 @@ export function useMultiTrackAudio( }, [video, src]); return { + unsupported, setMuted: applyMuted, setVolume: applyVolume, }; diff --git a/app/desktop-ui/ui/src/lib/player.ts b/app/desktop-ui/ui/src/lib/player.ts index a6af007..5b33ac8 100644 --- a/app/desktop-ui/ui/src/lib/player.ts +++ b/app/desktop-ui/ui/src/lib/player.ts @@ -18,3 +18,10 @@ export function resetPlayer(video: HTMLVideoElement | null): void { /* ignore */ } } + +export function ownsPlayerKeys(event: KeyboardEvent): boolean { + const target = event.target; + return target instanceof HTMLElement && !!target.closest( + "input, textarea, select, button, [contenteditable]:not([contenteditable=false]), [role=slider], [role=dialog], [role=alertdialog], .modal, .ctx-menu", + ); +} diff --git a/app/desktop-ui/ui/src/lib/settings-api.ts b/app/desktop-ui/ui/src/lib/settings-api.ts index 619ab4b..037f5a1 100644 --- a/app/desktop-ui/ui/src/lib/settings-api.ts +++ b/app/desktop-ui/ui/src/lib/settings-api.ts @@ -1,25 +1,63 @@ // Settings persist through the native host and trigger an engine reload. +import { signal } from "@preact/signals"; import { invoke } from "@tauri-apps/api/core"; export type Config = Record; -export async function getConfig(): Promise { - try { - const config = await invoke("get_settings"); - return config ?? null; - } catch { - return null; - } +export const settingsDraft = signal(null); +export const settingsSaveState = signal<"idle" | "saving" | "saved" | "error">("idle"); +export const settingsError = signal(null); +let loading: Promise | null = null; +let revision = 0; +let savedRevision = 0; +let timer: ReturnType | undefined; +let writing: Promise | null = null; + +export function getConfig(): Promise { + if (settingsDraft.value) return Promise.resolve(settingsDraft.value); + loading ??= invoke("get_settings").then((config) => { + settingsDraft.value = config; + return config; + }).catch(() => null).finally(() => { loading = null; }); + return loading; } -export async function saveConfig(config: Config): Promise<{ ok: boolean; error?: string }> { - try { - await invoke("save_settings", { config }); - return { ok: true }; - } catch (err) { - return { ok: false, error: String(err) }; - } +export function editConfig(mutate: (config: Config) => void, immediate = false): void { + if (!settingsDraft.value) return; + const draft = structuredClone(settingsDraft.value); + mutate(draft); + settingsDraft.value = draft; + ++revision; + settingsSaveState.value = "saving"; + settingsError.value = null; + clearTimeout(timer); + if (immediate) void flushConfig(); + else timer = setTimeout(() => { void flushConfig(); }, 500); +} + +export function flushConfig(): Promise { + clearTimeout(timer); + if (writing) return writing; + writing = (async () => { + while (savedRevision < revision && settingsDraft.value) { + const current = revision; + const config = structuredClone(settingsDraft.value); + try { + await invoke("save_settings", { config }); + savedRevision = current; + if (current === revision) { + settingsSaveState.value = "saved"; + settingsError.value = null; + } + } catch (error) { + settingsSaveState.value = "error"; + settingsError.value = String(error); + break; + } + } + })().finally(() => { writing = null; }); + return writing; } // Engine capabilities are best-effort snapshots from runtime-status.json. diff --git a/app/desktop-ui/ui/src/lib/window.ts b/app/desktop-ui/ui/src/lib/window.ts index bd76151..231d12c 100644 --- a/app/desktop-ui/ui/src/lib/window.ts +++ b/app/desktop-ui/ui/src/lib/window.ts @@ -1,16 +1,70 @@ // Custom title-bar window controls, driven by the native Tauri window API // (the webview now loads bundled assets and has the Tauri JS API available). +import { flushConfig, settingsError } from "./settings-api.ts"; +import { useEffect } from "preact/hooks"; import { getCurrentWindow } from "@tauri-apps/api/window"; const win = getCurrentWindow(); export const appWindow = { + isMaximized: () => win.isMaximized(), minimize: () => win.minimize(), maximize: () => win.maximize(), unmaximize: () => win.unmaximize(), toggleMaximize: () => win.toggleMaximize(), - close: () => win.close(), + close: async () => { + await flushConfig(); + if (!settingsError.value) await win.close(); + }, // startDragging() hands off to the OS move-loop; one call on mousedown is enough. startDrag: () => win.startDragging(), }; + +let playerTransition: Promise = Promise.resolve(); + +export function usePlayerWindow(active: boolean): void { + useEffect(() => { + if (!active) return; + let closed = false; + let changed = false; + playerTransition = playerTransition.then(async () => { + const maximized = await appWindow.isMaximized(); + if (!closed && !maximized) { + await appWindow.maximize(); + changed = true; + } + }).catch((error) => console.error("Player window transition failed", error)); + return () => { + closed = true; + playerTransition = playerTransition.then(async () => { + if (changed) await appWindow.unmaximize(); + }).catch((error) => console.error("Player window restore failed", error)); + }; + }, [active]); +} + +export function useSettingsClose(): void { + useEffect(() => { + let disposed = false; + let closing = false; + let unlisten: (() => void) | undefined; + void win.onCloseRequested(async (event) => { + event.preventDefault(); + if (closing || disposed) return; + closing = true; + try { + await flushConfig(); + if (!settingsError.value && !disposed) await win.destroy(); + } catch (error) { + settingsError.value = String(error); + } finally { + closing = false; + } + }).then((stop) => { + if (disposed) stop(); + else unlisten = stop; + }).catch((error) => { settingsError.value = String(error); }); + return () => { disposed = true; unlisten?.(); }; + }, []); +} diff --git a/app/desktop-ui/ui/src/settings/controls.tsx b/app/desktop-ui/ui/src/settings/controls.tsx index 57e6242..02a4ce7 100644 --- a/app/desktop-ui/ui/src/settings/controls.tsx +++ b/app/desktop-ui/ui/src/settings/controls.tsx @@ -1,8 +1,15 @@ -import type { ComponentChildren } from "preact"; -import { useLayoutEffect, useRef, useState } from "preact/hooks"; +import { createContext, type ComponentChildren } from "preact"; +import { useContext, useId, useLayoutEffect, useRef, useState } from "preact/hooks"; import { Icon } from "../shell/icons.tsx"; import { pickFolder } from "../lib/settings-api.ts"; +const FieldContext = createContext<{ label: string; description?: string } | null>(null); + +function useFieldLabel() { + const field = useContext(FieldContext); + return { "aria-labelledby": field?.label, "aria-describedby": field?.description }; +} + // A settings page is a stack of Sections; each Section is a titled card holding // a set of Fields. This gives every group a consistent frame, divider and rhythm. @@ -34,14 +41,17 @@ export function Field( htmlFor?: string; }, ) { + const id = useId(); return ( -
-
- - {help && {help}} + +
+
+ + {help && {help}} +
+
{control}
-
{control}
-
+ ); } @@ -52,6 +62,7 @@ export function Toggle( return ( + {(saveError || settingsError.value || engine.recording_error) && ( + )} {showConnectToast && ( diff --git a/app/desktop-ui/ui/styles.css b/app/desktop-ui/ui/styles.css index 2d743be..fbbba55 100644 --- a/app/desktop-ui/ui/styles.css +++ b/app/desktop-ui/ui/styles.css @@ -1569,3 +1569,7 @@ body { .set-field-control > .input, .set-field-control > .select { min-width: 0; width: 100%; } .duration-row { flex-wrap: wrap; } } + +.audio-track-notice { display: flex; align-items: center; gap: 12px; color: var(--text-dim); font-size: 12px; padding: 8px 0; } +.audio-track-notice .btn { flex-shrink: 0; } +.fs-track-notice { position: fixed; left: 24px; right: 24px; bottom: 100px; z-index: 110; padding: 0 12px; background: rgba(21, 21, 21, .9); border-radius: var(--r-lg); } diff --git a/app/recorder/src/updater.cpp b/app/recorder/src/updater.cpp index 5c9803e..59232c0 100644 --- a/app/recorder/src/updater.cpp +++ b/app/recorder/src/updater.cpp @@ -26,6 +26,11 @@ std::filesystem::path module_dir() // tree) and returns an empty path when it is not present. std::filesystem::path resolve_updater(const std::filesystem::path& base) { + std::error_code recovery_error; + const auto recovery = base / ".update-recovery" / "Updater.exe"; + if (std::filesystem::is_regular_file(base / ".update-transaction" / "journal.json", recovery_error) && + std::filesystem::is_regular_file(recovery, recovery_error)) + return recovery; const std::filesystem::path candidates[] = { base / "Updater.exe", // installed / CMake copy (app root) // Dev: running the recorder straight from a build tree, before the copy. diff --git a/app/updater/src-tauri/Cargo.toml b/app/updater/src-tauri/Cargo.toml index 842ae09..f2c2ce6 100644 --- a/app/updater/src-tauri/Cargo.toml +++ b/app/updater/src-tauri/Cargo.toml @@ -20,7 +20,7 @@ windows = { version = "0.58", features = [ "Win32_Foundation", "Win32_Security", "Win32_UI_WindowsAndMessaging", - "Win32_System_Threading", + "Win32_System_Threading", "Win32_System_Diagnostics_ToolHelp", "Win32_Storage_FileSystem", "Win32_Networking_WinHttp", ] } diff --git a/app/updater/src-tauri/src/download.rs b/app/updater/src-tauri/src/download.rs index 65b98da..fdc6432 100644 --- a/app/updater/src-tauri/src/download.rs +++ b/app/updater/src-tauri/src/download.rs @@ -1,69 +1,65 @@ -use base64::Engine; -use ed25519_dalek::{Signature, VerifyingKey}; use sha2::{Digest, Sha256}; use std::io::Read; use std::path::Path; -use std::sync::atomic::AtomicBool; +use std::sync::atomic::{AtomicBool, Ordering}; -// Release components are signed with the CI Ed25519 key; this is its public half. -const PUBLIC_KEY_B64: &str = "GgyaSRupUFn5Omaa90w0H2xDTrqff2DdzRDtbeplvKA="; - -/// Sentinel error string signalling a user cancel (not a failure). pub const CANCELLED: &str = "cancelled"; +pub fn check_cancel(cancel: &AtomicBool) -> Result<(), String> { + if cancel.load(Ordering::SeqCst) { + Err(CANCELLED.into()) + } else { + Ok(()) + } +} + pub fn download( - url: &str, + component: &str, + info: &crate::manifest::ComponentInfo, dest: &Path, - expected_size: u64, - expected_sha256: &str, - ed_signature_b64: &str, cancel: &AtomicBool, on_progress: &dyn Fn(u64), on_verify: &dyn Fn(), ) -> Result<(), String> { - crate::manifest::ComponentInfo { - version: "0.0.0".into(), - url: url.into(), - size: expected_size, - sha256: expected_sha256.into(), - ed_signature: ed_signature_b64.into(), - } - .validate()?; - let downloaded = crate::http::get_to_file(url, dest, expected_size, cancel, on_progress) - .map_err(|e| { - if e == "__cancelled" { - CANCELLED.to_string() - } else { - e - } - })?; - - on_verify(); - if expected_size > 0 && downloaded != expected_size { - let _ = std::fs::remove_file(dest); - return Err(format!( - "size mismatch - expected {expected_size} bytes, got {downloaded}" - )); - } - if !expected_sha256.is_empty() { - let digest = sha256_file(dest)?; - if !digest.eq_ignore_ascii_case(expected_sha256) { - let _ = std::fs::remove_file(dest); - return Err("checksum mismatch - the download is corrupt".to_string()); + info.authenticate(component)?; + check_cancel(cancel)?; + let result = (|| { + let downloaded = crate::http::get_to_file(&info.url, dest, info.size, cancel, on_progress) + .map_err(|e| { + if e == "__cancelled" { + CANCELLED.into() + } else { + e + } + })?; + on_verify(); + check_cancel(cancel)?; + if downloaded != info.size { + return Err("component size mismatch".into()); } - } - if let Err(e) = verify_signature(dest, ed_signature_b64) { + let digest = sha256_file_cancel(dest, cancel)?; + if !digest.eq_ignore_ascii_case(&info.sha256) { + return Err("component checksum mismatch".into()); + } + check_cancel(cancel) + })(); + if result.is_err() { let _ = std::fs::remove_file(dest); - return Err(e); } - Ok(()) + result } -fn sha256_file(path: &Path) -> Result { +fn sha256_file_cancel(path: &Path, cancel: &AtomicBool) -> Result { + check_cancel(cancel)?; let mut file = std::fs::File::open(path).map_err(|e| format!("re-read for verify: {e}"))?; + hash_reader(&mut file, cancel) +} + +fn hash_reader(file: &mut impl Read, cancel: &AtomicBool) -> Result { let mut hasher = Sha256::new(); let mut buf = [0u8; 64 * 1024]; loop { + check_cancel(cancel)?; let n = file .read(&mut buf) .map_err(|e| format!("re-read for verify: {e}"))?; @@ -72,38 +68,48 @@ fn sha256_file(path: &Path) -> Result { } hasher.update(&buf[..n]); } + check_cancel(cancel)?; Ok(format!("{:x}", hasher.finalize())) } -fn verify_signature(path: &Path, sig_b64: &str) -> Result<(), String> { - let key_bytes: [u8; 32] = base64::engine::general_purpose::STANDARD - .decode(PUBLIC_KEY_B64) - .map_err(|_| "bad public key encoding".to_string())? - .try_into() - .map_err(|_: Vec| "bad public key length".to_string())?; - let sig_bytes: [u8; 64] = base64::engine::general_purpose::STANDARD - .decode(sig_b64.trim()) - .map_err(|_| "bad signature encoding".to_string())? - .try_into() - .map_err(|_: Vec| "bad signature length".to_string())?; - let key = VerifyingKey::from_bytes(&key_bytes).map_err(|_| "bad public key".to_string())?; - let sig = Signature::from_bytes(&sig_bytes); - let msg = std::fs::read(path).map_err(|e| format!("read for verify: {e}"))?; - key.verify_strict(&msg, &sig) - .map_err(|_| "signature verification failed".to_string()) -} - #[cfg(test)] mod tests { use super::*; - #[test] - fn missing_and_forged_signatures_are_rejected() { - let path = std::env::temp_dir().join(format!("monolith-signature-{}", std::process::id())); - std::fs::write(&path, b"untrusted component").unwrap(); - assert!(verify_signature(&path, "").is_err()); - let forged = base64::engine::general_purpose::STANDARD.encode([0u8; 64]); - assert!(verify_signature(&path, &forged).is_err()); + fn cancelled_verification_does_not_accept_completed_download() { + let path = std::env::temp_dir().join(format!("monolith-cancel-{}", std::process::id())); + std::fs::write(&path, b"downloaded").unwrap(); + let cancel = AtomicBool::new(true); + assert_eq!(sha256_file_cancel(&path, &cancel), Err(CANCELLED.into())); std::fs::remove_file(path).unwrap(); } + + #[test] + fn hashing_bounds_reads_and_observes_cancellation_between_chunks() { + struct Reader<'a> { + cancel: &'a AtomicBool, + reads: usize, + } + impl Read for Reader<'_> { + fn read(&mut self, buf: &mut [u8]) -> std::io::Result { + assert!(buf.len() <= 64 * 1024); + self.reads += 1; + buf.fill(0); + self.cancel.store(true, Ordering::SeqCst); + Ok(buf.len()) + } + } + let cancel = AtomicBool::new(false); + let mut reader = Reader { + cancel: &cancel, + reads: 0, + }; + assert_eq!(hash_reader(&mut reader, &cancel), Err(CANCELLED.into())); + assert_eq!(reader.reads, 1); + cancel.store(false, Ordering::SeqCst); + assert_eq!( + hash_reader(&mut std::io::Cursor::new(b"abc"), &cancel).unwrap(), + format!("{:x}", Sha256::digest(b"abc")) + ); + } } diff --git a/app/updater/src-tauri/src/engine_rpc.rs b/app/updater/src-tauri/src/engine_rpc.rs index f2b972e..b07f227 100644 --- a/app/updater/src-tauri/src/engine_rpc.rs +++ b/app/updater/src-tauri/src/engine_rpc.rs @@ -1,7 +1,7 @@ use serde_json::{json, Value}; use std::io::{BufRead, BufReader, Write}; use std::net::{SocketAddr, TcpStream}; -use std::time::{Duration, Instant}; +use std::time::Duration; // Same newline-delimited JSON-RPC 2.0 control socket the main UI and the // Stream Deck plugin speak (libs/ipc): 127.0.0.1:45991, one request per @@ -104,15 +104,15 @@ pub fn request_engine_exit() { let _ = rpc("update_engine_exit"); } -pub fn wait_engine_exit(timeout: Duration) -> bool { - let start = Instant::now(); - loop { - if !engine_running() { - return true; - } - if start.elapsed() >= timeout { - return false; - } - std::thread::sleep(Duration::from_millis(300)); - } +pub fn ready_version(expected: &str) -> bool { + rpc("get_status") + .ok() + .and_then(|response| { + response + .get("result")? + .get("version")? + .as_str() + .map(str::to_owned) + }) + .is_some_and(|version| version == expected) } diff --git a/app/updater/src-tauri/src/install.rs b/app/updater/src-tauri/src/install.rs index 35b9e17..cccda7c 100644 --- a/app/updater/src-tauri/src/install.rs +++ b/app/updater/src-tauri/src/install.rs @@ -338,6 +338,25 @@ impl Transaction { next: digest(src)?, }); } + if entries + .iter() + .any(|entry| entry.path == Path::new("Updater.exe") && entry.prior.is_some()) + { + let recovery = root.join(".update-recovery"); + mkdir(&recovery)?; + let launcher = recovery.join("Updater.exe"); + if plain(&launcher)?.is_none() { + let temporary = recovery.join("Updater.tmp"); + let mut input = File::open(root.join("Updater.exe")).map_err(|e| e.to_string())?; + let mut output = File::create(&temporary).map_err(|e| e.to_string())?; + std::io::copy(&mut input, &mut output) + .and_then(|_| output.sync_all()) + .map_err(|e| e.to_string())?; + drop(output); + verify(&temporary, &digest(&root.join("Updater.exe"))?)?; + move_file(&temporary, &launcher, false)?; + } + } mkdir(&dir)?; for ((src, rel), e) in files.iter().zip(&entries) { let new = dir.join("new").join(rel); @@ -510,6 +529,30 @@ mod tests { } } + #[test] + fn updater_recovery_entry_survives_missing_normal_executable() { + let f = Fixture::new(); + let tx = Transaction::prepare( + &f.root, + &[(f.stage.join("Updater.exe"), "Updater.exe".into())], + ) + .unwrap(); + tx.place(&mut |step| { + if step == 1 { + Err("interrupted".into()) + } else { + Ok(()) + } + }) + .unwrap_err(); + assert!(!f.root.join("Updater.exe").exists()); + assert_eq!( + fs::read(f.root.join(".update-recovery/Updater.exe")).unwrap(), + b"old-Updater.exe" + ); + recover(&f.root).unwrap(); + f.original(); + } #[test] fn every_interrupted_move_restores_all_components_and_versions() { for fail_at in 1..=9 { @@ -650,6 +693,54 @@ mod tests { assert!(!other.join("UI.exe").exists()); } + #[cfg(windows)] + #[test] + #[ignore] + fn recovery_launcher_child() { + let root = crate::paths::app_dir(); + assert_eq!( + root, + PathBuf::from(std::env::var_os("MONOLITH_RECOVERY_ROOT").unwrap()) + ); + recover(&root).unwrap(); + } + + #[cfg(windows)] + #[test] + fn interrupted_self_update_can_launch_recovery_from_installation() { + for stop in [1, 2] { + let f = Fixture::new(); + let exe = f.root.join("Updater.exe"); + fs::copy(std::env::current_exe().unwrap(), &exe).unwrap(); + let original = digest(&exe).unwrap(); + let tx = Transaction::prepare( + &f.root, + &[(f.stage.join("Updater.exe"), "Updater.exe".into())], + ) + .unwrap(); + tx.place(&mut |step| { + if step == stop { + Err("interrupted".into()) + } else { + Ok(()) + } + }) + .unwrap_err(); + let status = std::process::Command::new(f.root.join(".update-recovery/Updater.exe")) + .args([ + "--ignored", + "--exact", + "install::tests::recovery_launcher_child", + ]) + .env("MONOLITH_RECOVERY_ROOT", &f.root) + .env_remove("MONOLITH_APP_DIR") + .status() + .unwrap(); + assert!(status.success()); + assert_eq!(digest(&exe).unwrap(), original); + } + } + #[cfg(windows)] #[test] #[ignore] diff --git a/app/updater/src-tauri/src/main.rs b/app/updater/src-tauri/src/main.rs index 17feca4..b060b87 100644 --- a/app/updater/src-tauri/src/main.rs +++ b/app/updater/src-tauri/src/main.rs @@ -10,6 +10,7 @@ mod http; mod install; mod manifest; mod paths; +mod process; mod state; mod versions; @@ -53,6 +54,7 @@ fn updater_start(app: AppHandle) { if core().phase() != Phase::Available || core().busy.swap(true, Ordering::SeqCst) { return; } + core().cancel.store(false, Ordering::SeqCst); std::thread::spawn(move || { run_pipeline(&app); core().busy.store(false, Ordering::SeqCst); @@ -61,7 +63,7 @@ fn updater_start(app: AppHandle) { #[tauri::command] fn updater_cancel() { - core().cancel.store(true, Ordering::Relaxed); + core().request_cancel(); } #[tauri::command] @@ -125,7 +127,7 @@ fn run_check(app: &AppHandle, auto: bool) { // Compare unparseable versions as strings to allow replacement. _ => from != to, }; - if force || newer { + if newer || (force && from == to) { comps.push(ComponentState { key: key.to_string(), from, @@ -210,7 +212,6 @@ fn set_comp(key: &str, mutate: impl FnOnce(&mut ComponentState)) { } fn run_pipeline(app: &AppHandle) { - core().cancel.store(false, Ordering::Relaxed); set_phase(app, Phase::Downloading); let app_dir = paths::app_dir(); @@ -278,27 +279,15 @@ fn run_pipeline(app: &AppHandle) { }; match download::download( - &info.url, + key, + info, &zip_path, - info.size, - &info.sha256, - &info.ed_signature, &core().cancel, &on_progress, &on_verify, ) { Err(e) if e == download::CANCELLED => { - let _ = std::fs::remove_dir_all(&staging); - { - let mut s = core().state.lock().unwrap(); - s.speed_bps = 0; - for c in s.components.iter_mut() { - c.status = CompStatus::Pending; - c.downloaded = 0; - } - s.phase = Phase::Available; - } - emit_state(app); + cancelled(app, &staging); return; } Err(e) => { @@ -317,9 +306,20 @@ fn run_pipeline(app: &AppHandle) { fail(app, "a recording is in progress - stop it and retry"); return; } - set_phase(app, Phase::Applying); + if !core().begin_apply() { + cancelled(app, &staging); + return; + } + emit_state(app); let has = |k: &str| keys.iter().any(|x| x == k); - let engine_was_running = engine_rpc::engine_running(); + let engine_processes = match process::EngineProcesses::capture(&app_dir.join("Monolith.exe")) { + Ok(processes) => processes, + Err(error) => { + fail(app, &error); + return; + } + }; + let engine_was_running = engine_processes.running(); let installed = { let s = core().state.lock().unwrap(); let mut v = s.installed.clone().unwrap_or(versions::Installed { @@ -369,7 +369,7 @@ fn run_pipeline(app: &AppHandle) { } if has("engine") && engine_was_running { engine_rpc::request_engine_exit(); - if !engine_rpc::wait_engine_exit(Duration::from_secs(20)) { + if engine_processes.wait_exit(Duration::from_secs(20)).is_err() { let restore = tx .abort() .err() @@ -412,16 +412,43 @@ fn run_pipeline(app: &AppHandle) { set_phase(app, Phase::Done); } +fn cancelled(app: &AppHandle, staging: &std::path::Path) { + let _ = std::fs::remove_dir_all(staging); + let mut s = core().state.lock().unwrap(); + s.speed_bps = 0; + for c in &mut s.components { + c.status = CompStatus::Pending; + c.downloaded = 0; + } + s.phase = Phase::Available; + drop(s); + emit_state(app); +} + fn recover_update(app_dir: &std::path::Path) -> Result<(), String> { let interrupted = install::pending(app_dir)?; - let running = interrupted && engine_rpc::engine_running(); + let engine_processes = if interrupted { + Some(process::EngineProcesses::capture( + &app_dir.join("Monolith.exe"), + )?) + } else { + None + }; + let running = engine_processes + .as_ref() + .is_some_and(|processes| processes.running()); if running { if engine_rpc::recording() { return Err("stop the recording before recovering the update".into()); } engine_rpc::close_ui()?; engine_rpc::request_engine_exit(); - if !engine_rpc::wait_engine_exit(Duration::from_secs(20)) { + if engine_processes + .as_ref() + .unwrap() + .wait_exit(Duration::from_secs(20)) + .is_err() + { return Err("close Monolith before recovering the update".into()); } } @@ -442,6 +469,19 @@ fn prepare_update( for key in keys { let src = staging.join(key); archive::extract_zip(&staging.join(format!("{key}.zip")), &src)?; + let (exe, expected) = match key.as_str() { + "engine" => ("Monolith.exe", &installed.engine), + "ui" => ("Monolith.UI.exe", &installed.ui), + "updater" => ("Updater.exe", &installed.updater), + _ => return Err("unknown component".into()), + }; + let payload_version = versions::file_version(&src.join(exe)) + .ok_or("component executable has no version metadata")?; + if three_part(&payload_version) != *expected { + return Err(format!( + "{key} payload version does not match signed metadata" + )); + } let prefix = if key == "ui" { std::path::Path::new("ui") } else { @@ -463,14 +503,17 @@ fn prepare_update( fn restart_engine(app_dir: &std::path::Path) -> Result<(), String> { use std::process::{Command, Stdio}; - Command::new(app_dir.join("Monolith.exe")) + let expected = versions::installed().engine; + let mut child = Command::new(app_dir.join("Monolith.exe")) .current_dir(app_dir) .stdin(Stdio::null()) .stdout(Stdio::null()) .stderr(Stdio::null()) .spawn() .map_err(|e| e.to_string())?; - Ok(()) + process::wait_ready(&mut child, Duration::from_secs(30), || { + engine_rpc::ready_version(&expected) + }) } fn focus_existing_instance() -> bool { diff --git a/app/updater/src-tauri/src/manifest.rs b/app/updater/src-tauri/src/manifest.rs index 6bbd1cb..9545693 100644 --- a/app/updater/src-tauri/src/manifest.rs +++ b/app/updater/src-tauri/src/manifest.rs @@ -4,9 +4,12 @@ use std::collections::BTreeMap; pub const DEFAULT_MANIFEST_URL: &str = "https://github.com/fraa2a/Monolith/releases/latest/download/update-manifest.json"; +pub const PUBLIC_KEY_B64: &str = "GgyaSRupUFn5Omaa90w0H2xDTrqff2DdzRDtbeplvKA="; + pub const MAX_COMPONENT_BYTES: u64 = 512 * 1024 * 1024; #[derive(Deserialize, Clone)] +#[serde(rename_all = "camelCase")] pub struct Manifest { pub schema: u32, #[serde(default)] @@ -17,6 +20,7 @@ pub struct Manifest { } #[derive(Deserialize, Clone, Default)] +#[serde(rename_all = "camelCase")] pub struct ReleaseInfo { #[serde(default)] pub tag: String, @@ -25,6 +29,7 @@ pub struct ReleaseInfo { } #[derive(Deserialize, Clone)] +#[serde(rename_all = "camelCase")] pub struct ComponentInfo { pub version: String, pub url: String, @@ -34,9 +39,47 @@ pub struct ComponentInfo { pub sha256: String, #[serde(default)] pub ed_signature: String, + #[serde(default)] + pub metadata_signature: String, } impl ComponentInfo { + fn authenticate_with_key( + &self, + component: &str, + key: &ed25519_dalek::VerifyingKey, + ) -> Result<(), String> { + use base64::Engine; + self.validate()?; + let bytes: [u8; 64] = base64::engine::general_purpose::STANDARD + .decode(self.metadata_signature.trim()) + .map_err(|_| "invalid metadata signature")? + .try_into() + .map_err(|_| "missing or invalid metadata signature")?; + let message = format!( + "monolith-component-v1\n{component}\n{}\n{}\n{}\n", + self.version, + self.size, + self.sha256.to_ascii_lowercase() + ); + key.verify_strict( + message.as_bytes(), + &ed25519_dalek::Signature::from_bytes(&bytes), + ) + .map_err(|_| "component metadata signature verification failed".into()) + } + + pub fn authenticate(&self, component: &str) -> Result<(), String> { + use base64::Engine; + let bytes: [u8; 32] = base64::engine::general_purpose::STANDARD + .decode(PUBLIC_KEY_B64) + .map_err(|_| "invalid public key")? + .try_into() + .map_err(|_| "invalid public key")?; + let key = + ed25519_dalek::VerifyingKey::from_bytes(&bytes).map_err(|_| "invalid public key")?; + self.authenticate_with_key(component, &key) + } pub fn validate(&self) -> Result<(), String> { semver::Version::parse(&self.version).map_err(|_| "invalid component version")?; if !self.url.starts_with("https://") || self.url.contains('\0') { @@ -91,5 +134,96 @@ pub fn fetch() -> Result { let m: Manifest = serde_json::from_value(value).map_err(|e| format!("invalid manifest: {e}"))?; m.validate()?; + for (component, info) in &m.components { + info.authenticate(component) + .map_err(|e| format!("{component}: {e}"))?; + } Ok(m) } + +#[cfg(test)] +mod tests { + use super::*; + #[test] + #[ignore = "requires a PowerShell-generated signed release fixture"] + fn generated_release_contract() { + use base64::Engine; + let path = std::env::var("MONOLITH_GENERATED_MANIFEST").unwrap(); + let text = std::fs::read_to_string(path).unwrap(); + #[derive(serde::Deserialize)] + struct LegacyComponent { + ed_signature: String, + } + #[derive(serde::Deserialize)] + struct LegacyManifest { + components: BTreeMap, + } + let legacy: LegacyManifest = serde_json::from_str(&text).unwrap(); + assert!(legacy + .components + .values() + .all(|component| !component.ed_signature.is_empty())); + let m: Manifest = serde_json::from_str(&text).unwrap(); + m.validate().unwrap(); + assert!(!m.published_at.is_empty()); + assert_eq!(m.components.len(), 3); + let bytes: [u8; 32] = base64::engine::general_purpose::STANDARD + .decode(std::env::var("MONOLITH_TEST_PUBLIC_KEY").unwrap()) + .unwrap() + .try_into() + .unwrap(); + let key = ed25519_dalek::VerifyingKey::from_bytes(&bytes).unwrap(); + let payload = std::fs::read(std::env::var("MONOLITH_TEST_PAYLOAD").unwrap()).unwrap(); + for (name, info) in m.components { + info.authenticate_with_key(&name, &key).unwrap(); + let signature: [u8; 64] = base64::engine::general_purpose::STANDARD + .decode(&info.ed_signature) + .unwrap() + .try_into() + .unwrap(); + key.verify_strict(&payload, &ed25519_dalek::Signature::from_bytes(&signature)) + .unwrap(); + assert_eq!( + legacy.components.get(&name).unwrap().ed_signature, + info.ed_signature + ); + } + } + #[test] + fn signed_identity_rejects_relabelled_old_payload() { + use base64::Engine; + use ed25519_dalek::{Signer, SigningKey}; + let key = SigningKey::from_bytes(&[7u8; 32]); + let mut info: ComponentInfo = serde_json::from_value(serde_json::json!({"version":"1.2.3","url":"https://example.com/a","size":1,"sha256":"ab".repeat(32),"edSignature":base64::engine::general_purpose::STANDARD.encode([0u8;64])})).unwrap(); + let message = format!("monolith-component-v1\nengine\n1.2.3\n1\n{}\n", info.sha256); + info.metadata_signature = base64::engine::general_purpose::STANDARD + .encode(key.sign(message.as_bytes()).to_bytes()); + info.authenticate_with_key("engine", &key.verifying_key()) + .unwrap(); + assert!(info + .authenticate_with_key("ui", &key.verifying_key()) + .is_err()); + info.version = "99.0.0".into(); + assert!(info + .authenticate_with_key("engine", &key.verifying_key()) + .is_err()); + info.version = "1.2.3".into(); + info.size = 2; + assert!(info + .authenticate_with_key("engine", &key.verifying_key()) + .is_err()); + info.size = 1; + info.sha256 = "cd".repeat(32); + assert!(info + .authenticate_with_key("engine", &key.verifying_key()) + .is_err()); + } + #[test] + fn camel_case_release_contract_round_trips() { + let json = serde_json::json!({"schema":1,"publishedAt":"date","release":{"notesUrl":"notes"},"components":{"engine":{"version":"1.2.3","url":"https://example.com/a","size":1,"sha256":"ab".repeat(32),"edSignature":base64::Engine::encode(&base64::engine::general_purpose::STANDARD,[0u8;64])}}}); + let m: Manifest = serde_json::from_value(json).unwrap(); + m.validate().unwrap(); + assert_eq!(m.published_at, "date"); + assert_eq!(m.release.notes_url, "notes"); + } +} diff --git a/app/updater/src-tauri/src/paths.rs b/app/updater/src-tauri/src/paths.rs index a62dd11..29d4cbf 100644 --- a/app/updater/src-tauri/src/paths.rs +++ b/app/updater/src-tauri/src/paths.rs @@ -15,11 +15,26 @@ pub fn app_dir() -> PathBuf { return PathBuf::from(dir); } } - let exe = exe_dir(); + resolve_app_dir(&exe_dir()) +} + +fn resolve_app_dir(exe: &std::path::Path) -> PathBuf { + for dir in exe.ancestors() { + if [".update-recovery", ".update-transaction"] + .iter() + .any(|name| dir.file_name().is_some_and(|n| n == *name)) + { + if let Some(root) = dir.parent() { + if root.join(".update-transaction/journal.json").is_file() { + return root.to_path_buf(); + } + } + } + } if exe.join("Monolith.exe").is_file() { - return exe; + return exe.to_path_buf(); } - let mut cur: Option<&std::path::Path> = Some(exe.as_path()); + let mut cur: Option<&std::path::Path> = Some(exe); while let Some(dir) = cur { if dir.join("app").join("desktop-ui").is_dir() && dir.join("app").join("updater").is_dir() { return dir @@ -30,9 +45,26 @@ pub fn app_dir() -> PathBuf { } cur = dir.parent(); } - exe + exe.to_path_buf() } pub fn staging_dir() -> PathBuf { app_dir().join("update-staging") } + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn recovery_and_backup_launches_find_installation_root() { + let root = std::env::temp_dir().join(format!("monolith-root-{}", std::process::id())); + std::fs::create_dir_all(root.join(".update-transaction/backup")).unwrap(); + std::fs::write(root.join(".update-transaction/journal.json"), b"{}").unwrap(); + assert_eq!(resolve_app_dir(&root.join(".update-recovery")), root); + assert_eq!( + resolve_app_dir(&root.join(".update-transaction/backup")), + root + ); + std::fs::remove_dir_all(root).unwrap(); + } +} diff --git a/app/updater/src-tauri/src/process.rs b/app/updater/src-tauri/src/process.rs new file mode 100644 index 0000000..938f81f --- /dev/null +++ b/app/updater/src-tauri/src/process.rs @@ -0,0 +1,228 @@ +#[cfg(windows)] +use std::path::Path; +use std::process::Child; +use std::time::{Duration, Instant}; + +pub fn wait_ready( + child: &mut Child, + timeout: Duration, + ready: impl Fn() -> bool, +) -> Result<(), String> { + let start = Instant::now(); + let mut ready_since = None; + loop { + if let Some(status) = child.try_wait().map_err(|e| e.to_string())? { + return Err(format!("engine exited during startup: {status}")); + } + if ready() { + let since = ready_since.get_or_insert_with(Instant::now); + if since.elapsed() >= Duration::from_millis(500) { + return Ok(()); + } + } else { + ready_since = None; + } + if start.elapsed() >= timeout { + return Err("engine readiness timed out".into()); + } + std::thread::sleep(Duration::from_millis(100)); + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + #[ignore] + fn short_lived_child() { + std::thread::sleep(Duration::from_millis(100)); + } + + #[test] + fn child_must_remain_alive_during_ready_handshake() { + let mut child = std::process::Command::new(std::env::current_exe().unwrap()) + .args(["--ignored", "--exact", "process::tests::short_lived_child"]) + .spawn() + .unwrap(); + assert!(wait_ready(&mut child, Duration::from_secs(3), || true).is_err()); + child.wait().unwrap(); + } + + #[cfg(windows)] + #[test] + #[ignore] + fn slow_exit_child() { + let root = std::path::PathBuf::from(std::env::var_os("MONOLITH_PROCESS_TEST").unwrap()); + std::fs::write(root.join("ready"), b"ready").unwrap(); + while !root.join("exit").exists() { + std::thread::sleep(Duration::from_millis(10)); + } + std::thread::sleep(Duration::from_millis(400)); + } + + #[cfg(windows)] + #[test] + fn closed_control_socket_does_not_mean_process_exited() { + let root = std::env::temp_dir().join(format!("monolith-process-{}", std::process::id())); + std::fs::create_dir_all(&root).unwrap(); + let exe = root.join("Monolith.exe"); + std::fs::copy(std::env::current_exe().unwrap(), &exe).unwrap(); + let mut child = std::process::Command::new(&exe) + .args(["--ignored", "--exact", "process::tests::slow_exit_child"]) + .env("MONOLITH_PROCESS_TEST", &root) + .spawn() + .unwrap(); + let result = std::panic::catch_unwind(|| { + for _ in 0..500 { + if root.join("ready").exists() { + break; + } + std::thread::sleep(Duration::from_millis(10)); + } + assert!(root.join("ready").exists()); + let processes = EngineProcesses::capture(&exe).unwrap(); + assert!(processes.running()); + std::fs::write(root.join("exit"), b"exit").unwrap(); + assert!(processes.wait_exit(Duration::from_millis(50)).is_err()); + processes.wait_exit(Duration::from_secs(5)).unwrap(); + }); + let _ = child.kill(); + let _ = child.wait(); + std::fs::remove_dir_all(root).unwrap(); + result.unwrap(); + } + #[test] + fn engine_that_exits_immediately_cannot_be_reported_ready() { + let mut command = if cfg!(windows) { + let mut command = std::process::Command::new("cmd"); + command.args(["/c", "exit", "1"]); + command + } else { + let mut command = std::process::Command::new("sh"); + command.args(["-c", "exit 1"]); + command + }; + let mut child = command.spawn().unwrap(); + child.wait().unwrap(); + assert!(wait_ready(&mut child, Duration::from_secs(1), || true).is_err()); + } +} + +#[cfg(windows)] +pub struct EngineProcesses(Vec); + +#[cfg(windows)] +impl Drop for EngineProcesses { + fn drop(&mut self) { + for handle in &self.0 { + unsafe { + let _ = windows::Win32::Foundation::CloseHandle(*handle); + } + } + } +} + +#[cfg(windows)] +impl EngineProcesses { + pub fn capture(exe: &Path) -> Result { + use windows::core::PWSTR; + use windows::Win32::Foundation::CloseHandle; + use windows::Win32::System::Diagnostics::ToolHelp::{ + CreateToolhelp32Snapshot, Process32FirstW, Process32NextW, PROCESSENTRY32W, + TH32CS_SNAPPROCESS, + }; + use windows::Win32::System::Threading::{ + OpenProcess, QueryFullProcessImageNameW, PROCESS_ACCESS_RIGHTS, PROCESS_NAME_WIN32, + PROCESS_QUERY_LIMITED_INFORMATION, + }; + let expected = std::fs::canonicalize(exe.parent().ok_or("engine path has no parent")?) + .map_err(|e| format!("engine directory: {e}"))? + .join(exe.file_name().ok_or("engine path has no filename")?); + let expected = expected + .to_string_lossy() + .trim_start_matches("\\\\?\\") + .to_lowercase(); + let mut processes = Self(Vec::new()); + unsafe { + let snapshot = + CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0).map_err(|e| e.to_string())?; + let result = (|| { + let mut entry = PROCESSENTRY32W { + dwSize: std::mem::size_of::() as u32, + ..Default::default() + }; + if Process32FirstW(snapshot, &mut entry).is_err() { + return Ok(()); + } + loop { + let len = entry + .szExeFile + .iter() + .position(|c| *c == 0) + .unwrap_or(entry.szExeFile.len()); + let name = String::from_utf16_lossy(&entry.szExeFile[..len]); + if exe + .file_name() + .is_some_and(|file| file.to_string_lossy().eq_ignore_ascii_case(&name)) + { + let handle = OpenProcess( + PROCESS_QUERY_LIMITED_INFORMATION | PROCESS_ACCESS_RIGHTS(0x00100000), + false, + entry.th32ProcessID, + ) + .map_err(|e| { + format!("opening engine process {}: {e}", entry.th32ProcessID) + })?; + let mut path = vec![0u16; 32768]; + let mut size = path.len() as u32; + let query = QueryFullProcessImageNameW( + handle, + PROCESS_NAME_WIN32, + PWSTR(path.as_mut_ptr()), + &mut size, + ); + if let Err(e) = query { + let _ = CloseHandle(handle); + return Err(format!("engine process path: {e}")); + } + let actual = String::from_utf16_lossy(&path[..size as usize]) + .trim_start_matches("\\\\?\\") + .to_lowercase(); + if actual == expected { + processes.0.push(handle); + } else { + let _ = CloseHandle(handle); + } + } + if Process32NextW(snapshot, &mut entry).is_err() { + break; + } + } + Ok(()) + })(); + let _ = CloseHandle(snapshot); + result?; + } + Ok(processes) + } + + pub fn running(&self) -> bool { + !self.0.is_empty() + } + + pub fn wait_exit(&self, timeout: Duration) -> Result<(), String> { + use windows::Win32::Foundation::WAIT_OBJECT_0; + use windows::Win32::System::Threading::WaitForSingleObject; + let start = Instant::now(); + for handle in &self.0 { + let remaining = timeout + .saturating_sub(start.elapsed()) + .as_millis() + .min(u32::MAX as u128 - 1) as u32; + if unsafe { WaitForSingleObject(*handle, remaining) } != WAIT_OBJECT_0 { + return Err("engine process did not exit in time".into()); + } + } + Ok(()) + } +} diff --git a/app/updater/src-tauri/src/state.rs b/app/updater/src-tauri/src/state.rs index f1c949d..3f5a8fe 100644 --- a/app/updater/src-tauri/src/state.rs +++ b/app/updater/src-tauri/src/state.rs @@ -1,7 +1,7 @@ use crate::manifest::Manifest; use crate::versions::Installed; use serde_json::{json, Value}; -use std::sync::atomic::AtomicBool; +use std::sync::atomic::{AtomicBool, AtomicU64, Ordering}; use std::sync::Mutex; #[derive(Clone, Copy, PartialEq, Eq, Debug)] @@ -77,6 +77,7 @@ pub struct SharedState { /// threads and the recording watcher. Every mutation is followed by an /// "update-state" emit; the frontend re-renders from snapshots only. pub struct Core { + revision: AtomicU64, pub state: Mutex, pub manifest: Mutex>, pub cancel: AtomicBool, @@ -86,6 +87,7 @@ pub struct Core { impl Core { pub fn new() -> Self { Core { + revision: AtomicU64::new(0), state: Mutex::new(SharedState { phase: Phase::Checking, tag: String::new(), @@ -107,6 +109,7 @@ impl Core { pub fn snapshot(&self) -> Value { let s = self.state.lock().unwrap(); json!({ + "revision": self.revision.fetch_add(1, Ordering::Relaxed), "phase": s.phase.as_str(), "tag": s.tag, "notesUrl": s.notes_url, @@ -132,7 +135,49 @@ impl Core { }) } + pub fn request_cancel(&self) { + let s = self.state.lock().unwrap(); + if s.phase == Phase::Downloading { + self.cancel.store(true, Ordering::SeqCst); + } + } + + pub fn begin_apply(&self) -> bool { + let mut s = self.state.lock().unwrap(); + if s.phase != Phase::Downloading || self.cancel.load(Ordering::SeqCst) { + return false; + } + s.phase = Phase::Applying; + true + } + pub fn phase(&self) -> Phase { self.state.lock().unwrap().phase } } + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn cancellation_wins_until_the_applying_transition() { + let core = Core::new(); + core.state.lock().unwrap().phase = Phase::Downloading; + core.request_cancel(); + assert!(!core.begin_apply()); + assert_eq!(core.phase(), Phase::Downloading); + core.cancel.store(false, Ordering::SeqCst); + assert!(core.begin_apply()); + core.request_cancel(); + assert!(!core.cancel.load(Ordering::SeqCst)); + assert_eq!(core.phase(), Phase::Applying); + } + + #[test] + fn snapshots_have_strictly_increasing_revisions() { + let core = Core::new(); + let first = core.snapshot()["revision"].as_u64().unwrap(); + let second = core.snapshot()["revision"].as_u64().unwrap(); + assert!(second > first); + } +} diff --git a/app/updater/src-tauri/src/versions.rs b/app/updater/src-tauri/src/versions.rs index 42e5e7b..de5cdee 100644 --- a/app/updater/src-tauri/src/versions.rs +++ b/app/updater/src-tauri/src/versions.rs @@ -41,7 +41,8 @@ fn read_components_json() -> Option { } /// Read the translation-independent fixed VERSIONINFO block. -fn file_version(path: &Path) -> Option { +#[cfg(windows)] +pub fn file_version(path: &Path) -> Option { if !path.is_file() { return None; } @@ -102,3 +103,8 @@ fn file_version(path: &Path) -> Option { }) } } + +#[cfg(not(windows))] +pub fn file_version(_: &Path) -> Option { + None +} diff --git a/app/updater/ui/src/state-stream.ts b/app/updater/ui/src/state-stream.ts new file mode 100644 index 0000000..2049e2c --- /dev/null +++ b/app/updater/ui/src/state-stream.ts @@ -0,0 +1,20 @@ +export function attachState( + listen: (receive: (value: T) => void) => Promise<() => void>, + snapshot: () => Promise, + receive: (value: T) => void, +): () => void { + let disposed = false; + let revision = -1; + let unlisten: (() => void) | undefined; + const accept = (value: T) => { + if (disposed || !Number.isSafeInteger(value.revision) || value.revision <= revision) return; + revision = value.revision; + receive(value); + }; + listen(accept).then(stop => { + if (disposed) { stop(); return; } + unlisten = stop; + return snapshot().then(accept); + }).catch(() => {}); + return () => { disposed = true; unlisten?.(); }; +} diff --git a/app/updater/ui/src/updater.tsx b/app/updater/ui/src/updater.tsx index 6e97689..e516eac 100644 --- a/app/updater/ui/src/updater.tsx +++ b/app/updater/ui/src/updater.tsx @@ -4,6 +4,7 @@ import { useEffect, useState } from "preact/hooks"; import { invoke } from "@tauri-apps/api/core"; import { listen } from "@tauri-apps/api/event"; import { getCurrentWindow } from "@tauri-apps/api/window"; +import { attachState } from "./state-stream"; import { openUrl } from "@tauri-apps/plugin-opener"; type Phase = @@ -33,6 +34,7 @@ interface InstalledVersions { } interface UpdateState { + revision: number; phase: Phase; tag: string; notesUrl: string; @@ -352,13 +354,11 @@ function BufferBar({ state }: { state: UpdateState }) { export function Updater() { const [state, setState] = useState(null); - useEffect(() => { - invoke("updater_state").then(setState).catch(() => {}); - const un = listen("update-state", (e) => setState(e.payload)); - return () => { - un.then((f) => f()); - }; - }, []); + useEffect(() => attachState( + receive => listen("update-state", event => receive(event.payload)), + () => invoke("updater_state"), + setState, + ), []); if (!state) { return ( @@ -367,6 +367,7 @@ export function Updater() { running.store(false, std::memory_order_release); break; } @@ -237,7 +261,10 @@ static void capture_thread(ImplT* impl) UINT64 qpc = 0; hr = impl->cap_client->GetBuffer(&data, &frames, &flags, nullptr, &qpc); - if (FAILED(hr)) break; + if (FAILED(hr)) { + audio_log("audio", "GetBuffer failed; scheduling source recovery"); + impl->running.store(false, std::memory_order_release); break; + } const bool silent = (flags & AUDCLNT_BUFFERFLAGS_SILENT) != 0; const uint32_t bytes = frames @@ -246,6 +273,13 @@ static void capture_thread(ImplT* impl) PacketInfo pkt{}; pkt.timestamp_qpc = static_cast(qpc); + if (flags & AUDCLNT_BUFFERFLAGS_TIMESTAMP_ERROR) { + LARGE_INTEGER now{}, freq{}; + QueryPerformanceCounter(&now); QueryPerformanceFrequency(&freq); + pkt.timestamp_qpc = (now.QuadPart / freq.QuadPart) * 10000000 + + (now.QuadPart % freq.QuadPart) * 10000000 / freq.QuadPart - + static_cast(frames) * 10000000 / impl->mix_fmt->nSamplesPerSec; + } pkt.frame_count = frames; pkt.sample_rate = impl->mix_fmt->nSamplesPerSec; pkt.channels = static_cast(impl->mix_fmt->nChannels); @@ -675,6 +709,9 @@ ActiveGameResult detect_active_game(const DetectConfig& cfg) WasapiCapture::WasapiCapture() : impl_(new Impl()) {} WasapiCapture::~WasapiCapture() { stop(); delete impl_; } bool WasapiCapture::running() const { return impl_->running.load(std::memory_order_relaxed); } +bool WasapiCapture::needs_restart() const { + return !running() || (impl_->notifications && impl_->notifications->changed.load()); +} bool WasapiCapture::start(Mode mode, PacketCallback cb) { @@ -699,6 +736,10 @@ bool WasapiCapture::start_device(Mode mode, const std::wstring& device_id_value, // Loopback: render endpoint + AUDCLNT_STREAMFLAGS_LOOPBACK. // Microphone: capture endpoint, no extra flags. if (device_id_value.empty()) { + impl_->notifications.attach(new EndpointNotifications); + impl_->notifications->flow = mode == Mode::Loopback ? eRender : eCapture; + if (FAILED(impl_->enumerator->RegisterEndpointNotificationCallback(impl_->notifications.get()))) + impl_->notifications = nullptr; EDataFlow flow = (mode == Mode::Loopback) ? eRender : eCapture; hr = impl_->enumerator->GetDefaultAudioEndpoint( flow, eConsole, impl_->device.put()); @@ -911,6 +952,9 @@ void WasapiCapture::stop() impl_->cap_client = nullptr; impl_->client = nullptr; impl_->device = nullptr; + if (impl_->enumerator && impl_->notifications) + impl_->enumerator->UnregisterEndpointNotificationCallback(impl_->notifications.get()); + impl_->notifications = nullptr; impl_->enumerator = nullptr; impl_->cb = nullptr; impl_->seq.store(0, std::memory_order_relaxed); diff --git a/libs/audio/audio.h b/libs/audio/audio.h index cd9b40a..229cd86 100644 --- a/libs/audio/audio.h +++ b/libs/audio/audio.h @@ -128,6 +128,7 @@ class WasapiCapture { bool start_process_loopback(uint32_t process_id, PacketCallback cb); void stop(); bool running() const; + bool needs_restart() const; private: struct Impl; diff --git a/libs/capture/capture.cpp b/libs/capture/capture.cpp index d99e682..5254215 100644 --- a/libs/capture/capture.cpp +++ b/libs/capture/capture.cpp @@ -81,6 +81,9 @@ struct DisplayCapture::Impl { wgc::Direct3D11CaptureFramePool pool{ nullptr }; wgc::GraphicsCaptureSession session{ nullptr }; winrt::event_token frame_token{}; + winrt::event_token closed_token{}; + wgc::GraphicsCaptureItem item{nullptr}; + bool closed_registered = false; winrt::Windows::Graphics::SizeInt32 last_size{}; std::atomic active{ false }; @@ -304,6 +307,11 @@ bool DisplayCapture::start(HMONITOR hmon, FrameCallback cb, CaptureOptions optio auto item = options.target_window ? item_from_window(options.target_window) : item_from_monitor(hmon); + impl_->item = item; + impl_->closed_token = item.Closed([state = impl_](auto const&, auto const&) { + state->active.store(false, std::memory_order_release); + }); + impl_->closed_registered = true; impl_->last_size = item.Size(); // CreateFreeThreaded: callbacks arrive on the WinRT thread pool regardless @@ -474,6 +482,10 @@ bool DisplayCapture::start(HMONITOR hmon, FrameCallback cb, CaptureOptions optio void DisplayCapture::stop() { impl_->active.store(false, std::memory_order_release); + if (impl_->closed_registered && impl_->item) { + impl_->item.Closed(impl_->closed_token); impl_->closed_registered = false; + } + impl_->item = nullptr; if (impl_->handler_registered && impl_->pool) { impl_->pool.FrameArrived(impl_->frame_token); impl_->handler_registered = false; diff --git a/libs/disk-segments/disk_segments.cpp b/libs/disk-segments/disk_segments.cpp index 935ec8e..bd19148 100644 --- a/libs/disk-segments/disk_segments.cpp +++ b/libs/disk-segments/disk_segments.cpp @@ -1,5 +1,7 @@ #include "disk_segments.h" #include "disk_budget.h" +#include "session_directory.h" +#include #include #include extern "C" { @@ -19,13 +21,14 @@ namespace mux = encoding::mux; namespace fs = std::filesystem; namespace { constexpr double kSegmentSeconds = 5.0; -std::atomic directory_sequence{0}; struct Segment { encoding::ClipSegment clip; uint64_t payload = 0; uint64_t file_bytes = 0; bool retained = true; bool owns_parent = true; + std::shared_ptr session; + std::shared_ptr guard; }; } struct DiskSegmentBuffer::Impl { @@ -42,6 +45,9 @@ struct DiskSegmentBuffer::Impl { std::shared_ptr current; std::vector> files; // includes pinned/failed-delete files fs::path owned_dir; + std::shared_ptr session; + std::chrono::steady_clock::time_point space_checked{}; + uint64_t available_space = 0; uint64_t sequence = 0; uint64_t payload = 0; uint64_t dropped = 0; @@ -131,24 +137,27 @@ struct DiskSegmentBuffer::Impl { std::error_code ec; fs::create_directories(cfg.segment_dir, ec); if (ec) return false; - for (int i = 0; i < 16; ++i) { - const auto stamp = std::chrono::steady_clock::now().time_since_epoch().count(); - auto path = fs::path(cfg.segment_dir) / (L"monolith-segments-" + std::to_wstring(stamp) + L"-" + - std::to_wstring(directory_sequence.fetch_add(1))); - if (fs::create_directory(path, ec)) { owned_dir = std::move(path); return true; } - if (ec) return false; - } - return false; + if (!SessionDirectory::reclaim(cfg.segment_dir)) { pressure = true; return false; } + session = std::make_shared(); + if (!session->create(cfg.segment_dir)) return false; + owned_dir = session->path(); return true; } bool free_space(uint64_t bytes) { std::error_code ec; - auto space = fs::space(owned_dir, ec); - return !ec && space.available >= kFreeSpaceReserve && bytes <= space.available - kFreeSpaceReserve; + const auto now = std::chrono::steady_clock::now(); + if (now - space_checked > std::chrono::seconds(1)) { + const auto space = fs::space(owned_dir, ec); if (ec) return false; + available_space = space.available; space_checked = now; + } + if (available_space < kFreeSpaceReserve || bytes > available_space - kFreeSpaceReserve) return false; + available_space -= bytes; return true; } bool open_segment(const encoding::EncodedPacket& key) { if (!ensure_directory()) return false; auto file = std::make_shared(); file->clip.path = (owned_dir / (L"seg_" + std::to_wstring(sequence++) + L"." + mux::file_extension(cfg.container))).wstring(); + file->session = session; + file->guard = std::make_shared(file->clip.path); file->clip.start_seconds = static_cast(key.dts_usec) / 1000000.0; file->clip.end_seconds = file->clip.start_seconds; // DTS zero is the common mux origin. Preserve composition delay and @@ -171,7 +180,8 @@ struct DiskSegmentBuffer::Impl { close_segment(); if (!owned_dir.empty() && owned_dir.parent_path() != fs::path(cfg.segment_dir)) { std::error_code ec; fs::remove(owned_dir, ec); // empty only; pinned files keep their parent - owned_dir.clear(); + owned_dir.clear(); session.reset(); + available_space = 0; space_checked = {}; } reconfigure = false; } @@ -203,6 +213,10 @@ void DiskSegmentBuffer::clear() { impl_->stop_save(); std::lock_guard lk(impl_->mutex); impl_->close_segment(true); impl_->purge(true); impl_->newest = 0; + if (impl_->files.empty()) { + impl_->session.reset(); impl_->owned_dir.clear(); + impl_->available_space = 0; impl_->space_checked = {}; + } } void DiskSegmentBuffer::set_video_params(encoding::VideoStreamParams const& p) { std::lock_guard lk(impl_->mutex); @@ -297,6 +311,7 @@ bool DiskSegmentBuffer::save_clip(const std::wstring& out_dir, std::functionsave_thread = std::thread([this, pinned = std::move(pinned), failed_output = std::move(failed_output), cfg, newest, out_dir, cb = std::move(cb)]() mutable { try { std::wstring result, path; + std::shared_ptr guard; try { std::vector segs; for (const auto& file : pinned) segs.push_back(file->clip); @@ -304,6 +319,7 @@ bool DiskSegmentBuffer::save_clip(const std::wstring& out_dir, std::function(path); const double start = std::max(segs.front().start_seconds, newest - cfg.duration_sec); std::string err; if (encoding::concat_clip_segments(segs, start, newest, path, &err, nullptr, &impl_->cancel)) result = path; diff --git a/libs/disk-segments/session_directory.h b/libs/disk-segments/session_directory.h new file mode 100644 index 0000000..52994f2 --- /dev/null +++ b/libs/disk-segments/session_directory.h @@ -0,0 +1,120 @@ +#pragma once +#include +#include +#include +#include +#include +#ifdef _WIN32 +#include +#else +#include +#include +#include +#endif +namespace disk_segments { +class SessionDirectory { + std::filesystem::path path_; +#ifdef _WIN32 + HANDLE lock_ = INVALID_HANDLE_VALUE; +#else + int lock_ = -1; +#endif + bool acquire(const std::filesystem::path& marker, bool create) { +#ifdef _WIN32 + lock_ = CreateFileW(marker.c_str(), GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, + nullptr, create ? CREATE_NEW : OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr); + return lock_ != INVALID_HANDLE_VALUE; +#else + lock_ = ::open(marker.c_str(), O_RDWR | (create ? O_CREAT | O_EXCL : 0), 0600); + if (lock_ < 0) return false; + if (flock(lock_, LOCK_EX | LOCK_NB) == 0) return true; + ::close(lock_); lock_ = -1; return false; +#endif + } + void release() { +#ifdef _WIN32 + if (lock_ != INVALID_HANDLE_VALUE) CloseHandle(lock_); + lock_ = INVALID_HANDLE_VALUE; +#else + if (lock_ >= 0) ::close(lock_); + lock_ = -1; +#endif + } + static bool segment(const std::filesystem::path& path) { + const auto stem = path.stem().string(); + if (path.extension() != ".mkv" && path.extension() != ".mp4") return false; + return stem.starts_with("seg_") && stem.size() > 4 && + stem.find_first_not_of("0123456789", 4) == std::string::npos; + } +public: + ~SessionDirectory() { + release(); + if (path_.empty()) return; + std::error_code ec; + std::filesystem::directory_iterator files(path_, ec); + if (ec) return; + size_t count = 0; + for (const auto& file : files) if (file.path().filename() != "owner.lock") ++count; + if (!count) { + std::filesystem::remove(path_ / "owner.lock", ec); + if (!ec) std::filesystem::remove(path_, ec); + } + } + const std::filesystem::path& path() const { return path_; } + bool create(const std::filesystem::path& root) { + release(); static std::atomic sequence{0}; + std::error_code ec; + for (int i = 0; i < 16; ++i) { + auto path = root / ("monolith-segments-" + std::to_string( + std::chrono::steady_clock::now().time_since_epoch().count()) + "-" + + std::to_string(sequence.fetch_add(1))); + if (!std::filesystem::create_directory(path, ec)) { if (ec) return false; continue; } + if (!acquire(path / "owner.lock", true)) return false; +#ifdef _WIN32 + const char magic[] = "Monolith disk session v1"; DWORD written = 0; + if (!WriteFile(lock_, magic, sizeof(magic) - 1, &written, nullptr) || + written != sizeof(magic) - 1 || !FlushFileBuffers(lock_)) { release(); return false; } +#else + const std::string magic = "Monolith disk session v1"; + if (::write(lock_, magic.data(), magic.size()) != static_cast(magic.size()) || + fsync(lock_) != 0) { release(); return false; } +#endif + path_ = std::move(path); return true; + } + return false; + } + static bool reclaim(const std::filesystem::path& root) { + namespace fs = std::filesystem; std::error_code ec; + fs::directory_iterator entries(root, ec); if (ec) return false; + for (auto it = entries; it != fs::directory_iterator(); it.increment(ec)) { + if (ec) return false; + const auto dir = it->path(); + if (!dir.filename().string().starts_with("monolith-segments-")) continue; + if (it->is_symlink(ec) || ec || !it->is_directory(ec)) continue; + const auto marker = dir / "owner.lock"; + if (fs::is_symlink(marker, ec) || ec) continue; + std::ifstream in(marker, std::ios::binary); + const std::string magic((std::istreambuf_iterator(in)), {}); + if (magic != "Monolith disk session v1") continue; + in.close(); SessionDirectory dead; + if (!dead.acquire(marker, false)) continue; + bool foreign = false; + fs::directory_iterator files(dir, ec); if (ec) return false; + for (auto file = files; file != fs::directory_iterator(); file.increment(ec)) { + if (ec) return false; + if (file->path() == marker) continue; + if (file->is_symlink(ec) || ec || !file->is_regular_file(ec) || !segment(file->path())) { + foreign = true; continue; + } + fs::remove(file->path(), ec); if (ec) return false; + } + dead.release(); + if (!foreign) { + fs::remove(marker, ec); if (ec) return false; + fs::remove(dir, ec); if (ec) return false; + } + } + return !ec; + } +}; +} diff --git a/libs/encoding/encoding.cpp b/libs/encoding/encoding.cpp index 092e746..26a6610 100644 --- a/libs/encoding/encoding.cpp +++ b/libs/encoding/encoding.cpp @@ -694,7 +694,7 @@ static AVSampleFormat wasapi_to_av_fmt(int bit_depth, bool is_float) void AudioEncoder::push_pcm(const uint8_t* data, int bytes, int sample_rate, int channels, - int bit_depth, bool is_float) + int bit_depth, bool is_float, int64_t capture_us) { std::lock_guard lk(impl_->mutex); if (!impl_->ctx || bytes <= 0) return; @@ -706,6 +706,19 @@ void AudioEncoder::push_pcm(const uint8_t* data, int bytes, const int src_frames = input.frames; const uint8_t* src_data = input.data; + if (capture_us >= 0) { + const int64_t captured = av_rescale(capture_us, impl_->cfg_sample_rate, 1000000); + const int queued = av_audio_fifo_size(impl_->fifo); + const int64_t expected = impl_->next_pts + queued; + const int64_t tolerance = impl_->cfg_sample_rate / 20; + if (impl_->next_pts == 0 && queued == 0) impl_->next_pts = captured; + else if (captured > expected + tolerance) { + av_audio_fifo_reset(impl_->fifo); + if (impl_->swr) swr_free(&impl_->swr); + impl_->next_pts = captured; + } else if (captured + tolerance < expected) return; + } + // (Re-)init swr if the input format changed. bool need_swr = !impl_->swr || impl_->swr_src_rate != sample_rate diff --git a/libs/encoding/encoding.h b/libs/encoding/encoding.h index 1c6d12a..f2e55c7 100644 --- a/libs/encoding/encoding.h +++ b/libs/encoding/encoding.h @@ -175,7 +175,7 @@ class AudioEncoder { // is_float: true for IEEE float (32-bit), false for signed PCM. void push_pcm(const uint8_t* data, int bytes, int sample_rate, int channels, - int bit_depth, bool is_float); + int bit_depth, bool is_float, int64_t capture_us = -1); void flush(); void close(); diff --git a/libs/encoding/media_ownership.h b/libs/encoding/media_ownership.h new file mode 100644 index 0000000..91c728b --- /dev/null +++ b/libs/encoding/media_ownership.h @@ -0,0 +1,45 @@ +#pragma once +#include +#include +#include +#include +#include +#include +namespace encoding { +namespace detail { +inline std::mutex media_mutex; +inline std::map media_writers; +inline std::wstring media_key(const std::wstring& path) { + std::error_code ec; + auto key = std::filesystem::weakly_canonical(path, ec); + auto result = ec ? path : key.wstring(); +#ifdef _WIN32 + std::transform(result.begin(), result.end(), result.begin(), ::towlower); +#endif + return result; +} +} +// Keep ownership from before file creation until catalog publication. +class MediaWriteGuard { +public: + explicit MediaWriteGuard(const std::wstring& path) : key_(detail::media_key(path)) { + std::lock_guard lock(detail::media_mutex); + ++detail::media_writers[key_]; + } + ~MediaWriteGuard() { + std::lock_guard lock(detail::media_mutex); + auto found = detail::media_writers.find(key_); + if (found != detail::media_writers.end() && --found->second == 0) + detail::media_writers.erase(found); + } + MediaWriteGuard(const MediaWriteGuard&) = delete; + MediaWriteGuard& operator=(const MediaWriteGuard&) = delete; +private: + std::wstring key_; +}; +inline bool media_is_owned(const std::wstring& path) { + const auto key = detail::media_key(path); + std::lock_guard lock(detail::media_mutex); + return detail::media_writers.contains(key); +} +} diff --git a/libs/logging/log_writer.h b/libs/logging/log_writer.h new file mode 100644 index 0000000..79b7d22 --- /dev/null +++ b/libs/logging/log_writer.h @@ -0,0 +1,123 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#ifdef _WIN32 +#include +#endif + +namespace logging { +class LogWriter { +public: + explicit LogWriter(std::filesystem::path path, uint64_t limit = 5 * 1024 * 1024, + int backups = 3, size_t queue_limit = 128 * 1024) + : path_(std::move(path)), limit_(limit), backups_(backups), queue_limit_(queue_limit), + worker_([this] { run(); }) {} + ~LogWriter() { + { std::lock_guard lock(mutex_); stopping_ = true; } + ready_.notify_one(); + worker_.join(); + } + LogWriter(const LogWriter&) = delete; + LogWriter& operator=(const LogWriter&) = delete; + bool write(std::string record) { + std::lock_guard lock(mutex_); + if (stopping_ || record.size() > queue_limit_ - queued_bytes_) return false; + queued_bytes_ += record.size(); + queue_.push_back(std::move(record)); + ready_.notify_one(); + return true; + } +private: + FILE* open() const { +#ifdef _WIN32 + return _wfsopen(path_.c_str(), L"ab", _SH_DENYNO); +#else + return std::fopen(path_.c_str(), "ab"); +#endif + } + bool rotate() const { + std::error_code ec; + for (int i = backups_; i >= 1; --i) { + auto source = path_; + if (i > 1) source += "." + std::to_string(i - 1); + auto target = path_; + target += "." + std::to_string(i); + const bool present = std::filesystem::exists(source, ec); + if (ec) return false; + if (!present) continue; + std::filesystem::remove(target, ec); + if (ec) return false; + std::filesystem::rename(source, target, ec); + if (ec) return false; + } + return true; + } + static void fallback(const std::string& records) { + std::fwrite(records.data(), 1, records.size(), stderr); + } + void run() { + FILE* file = nullptr; + uint64_t bytes = 0; + std::string pending; + for (;;) { + std::deque batch; + { + std::unique_lock lock(mutex_); + ready_.wait(lock, [this] { return stopping_ || !queue_.empty(); }); + if (queue_.empty() && stopping_) break; + batch.swap(queue_); + queued_bytes_ = 0; + } + for (const auto& record : batch) { + if (!file) { + std::error_code ec; + const auto size = std::filesystem::file_size(path_, ec); + bytes = ec ? 0 : size; + file = open(); + } + if (file && bytes != 0 && (bytes >= limit_ || record.size() > limit_ - bytes)) { + if (std::fclose(file) != 0) fallback(pending); + pending.clear(); + file = nullptr; + if (rotate()) bytes = 0; + file = open(); + } + if (!file || std::fwrite(record.data(), 1, record.size(), file) != record.size()) { + fallback(pending); + fallback(record); + pending.clear(); + if (file) std::fclose(file); + file = nullptr; + } else { + pending += record; + bytes += record.size(); + } + } + if (file && std::fflush(file) != 0) { + fallback(pending); + std::fclose(file); + file = nullptr; + } + pending.clear(); + } + if (file) std::fclose(file); + } + std::filesystem::path path_; + uint64_t limit_; + int backups_; + size_t queue_limit_; + std::mutex mutex_; + std::condition_variable ready_; + std::deque queue_; + size_t queued_bytes_ = 0; + bool stopping_ = false; + std::thread worker_; +}; +} // namespace logging diff --git a/libs/logging/logging.cpp b/libs/logging/logging.cpp index 7ec9a63..51979f9 100644 --- a/libs/logging/logging.cpp +++ b/libs/logging/logging.cpp @@ -1,4 +1,5 @@ #include "logging.h" +#include "log_writer.h" #ifndef WIN32_LEAN_AND_MEAN #define WIN32_LEAN_AND_MEAN @@ -7,7 +8,7 @@ #define NOMINMAX #endif #include -#include +#include #include #include @@ -17,68 +18,24 @@ namespace logging { namespace { bool g_enabled = false; -std::wstring g_dir; -FILE* g_file = nullptr; std::mutex g_mutex; +std::unique_ptr g_writer; -std::wstring log_file_path() +void write_locked(const char* record) { - return g_dir + L"\\monolith.log"; -} - -bool file_size_bytes(const std::wstring& path, uint64_t* size) -{ - WIN32_FILE_ATTRIBUTE_DATA data{}; - if (!GetFileAttributesExW(path.c_str(), GetFileExInfoStandard, &data)) - return false; - if (size) { - *size = (static_cast(data.nFileSizeHigh) << 32) | - static_cast(data.nFileSizeLow); - } - return true; -} - -void rotate_log_if_needed(const std::wstring& path, uint64_t max_bytes, int backups) -{ - uint64_t size = 0; - if (!file_size_bytes(path, &size) || size <= max_bytes) - return; - - for (int i = backups; i >= 1; --i) { - std::wstring src = (i == 1) ? path : (path + L"." + std::to_wstring(i - 1)); - std::wstring dst = path + L"." + std::to_wstring(i); - if (i == backups) - DeleteFileW(dst.c_str()); - MoveFileExW(src.c_str(), dst.c_str(), MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH); + if (!g_writer || !g_writer->write(record)) { + OutputDebugStringA("Monolith log queue unavailable or full\n"); + std::fputs(record, stderr); } } -// Must hold g_mutex. -void open_locked() -{ - if (g_file || g_dir.empty()) return; - std::wstring path = log_file_path(); - rotate_log_if_needed(path, 5ull * 1024ull * 1024ull, 3); - // _SH_DENYNO: keep the log readable by Settings/diagnostics while we run. - g_file = _wfsopen(path.c_str(), L"a", _SH_DENYNO); -} - -// Must hold g_mutex. -void close_locked() -{ - if (!g_file) return; - fclose(g_file); - g_file = nullptr; -} - } // namespace void init(bool enabled, const std::wstring& dir) { std::lock_guard lk(g_mutex); - g_dir = dir; + g_writer = std::make_unique(std::filesystem::path(dir) / L"monolith.log"); g_enabled = enabled; - if (g_enabled) open_locked(); } void set_enabled(bool enabled) @@ -86,8 +43,6 @@ void set_enabled(bool enabled) std::lock_guard lk(g_mutex); if (enabled == g_enabled) return; g_enabled = enabled; - if (g_enabled) open_locked(); - else close_locked(); } bool enabled() @@ -109,7 +64,7 @@ void log(const char* tag, const char* msg) st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond, tag, msg); - if (g_file) { fputs(buf, g_file); fflush(g_file); } + write_locked(buf); OutputDebugStringA(buf); } @@ -126,10 +81,8 @@ void log_error(const char* tag, const char* msg) st.wHour, st.wMinute, st.wSecond, tag, msg); - // Error records bypass verbose logging and may open the log file. OutputDebugStringA(buf); - if (!g_file) open_locked(); - if (g_file) { fputs(buf, g_file); fflush(g_file); } + write_locked(buf); } } // namespace logging diff --git a/libs/logging/logging.h b/libs/logging/logging.h index 39c35bd..8659ad7 100644 --- a/libs/logging/logging.h +++ b/libs/logging/logging.h @@ -16,7 +16,7 @@ bool enabled(); void log(const char* tag, const char* msg); -// Error logging bypasses enabled() and opens the file on demand. +// Error logging bypasses enabled() and queues persistent output. void log_error(const char* tag, const char* msg); } // namespace logging diff --git a/libs/recording/recording.cpp b/libs/recording/recording.cpp index 3f24eb8..51efb73 100644 --- a/libs/recording/recording.cpp +++ b/libs/recording/recording.cpp @@ -1,6 +1,7 @@ #include "recording.h" #include +#include extern "C" { #include @@ -39,10 +40,13 @@ struct StreamTiming { struct ManualRecorder::Impl { mutable std::mutex mutex; - RecordingState state = RecordingState::Idle; + std::atomic state{RecordingState::Idle}; + mutable std::mutex error_mutex; + std::string error; std::wstring output_dir; std::string container = "mkv"; std::wstring path; + std::shared_ptr guard; encoding::VideoStreamParams vsp; std::vector audio_params; @@ -147,7 +151,8 @@ static bool write_packet(ImplT* impl, const encoding::EncodedPacket& ep) dst_stream = impl->video_stream; else dst_stream = impl->audio_streams[ep.stream_index]; - if (!dst_stream) return false; + // A track introduced after the header is deferred to the next recording. + if (!dst_stream) return ep.stream_index != 0; StreamTiming& timing = impl->timing[ep.stream_index]; const auto origin = av_rescale_q(impl->origin_pts, AVRational{impl->origin_num, impl->origin_den}, @@ -207,6 +212,8 @@ bool ManualRecorder::start(std::wstring output_dir, std::string container) impl_->output_dir = std::move(output_dir); impl_->container = (container == "mp4") ? "mp4" : "mkv"; impl_->path = generate_recording_path(impl_->output_dir, impl_->container); + { std::lock_guard error_lock(impl_->error_mutex); impl_->error.clear(); } + impl_->guard = std::make_shared(impl_->path); impl_->state = RecordingState::Recording; return true; } @@ -233,18 +240,27 @@ bool ManualRecorder::stop(std::wstring* output_path) std::lock_guard lk(impl_->mutex); if (impl_->state == RecordingState::Idle) return false; const bool wrote_packet = impl_->wrote_packet; + const bool failed = impl_->state == RecordingState::Failed; const bool complete = close_output(impl_); if (!complete) std::fprintf(stderr, "[recording] output could not be finalized\n"); if (output_path) *output_path = complete && wrote_packet ? impl_->path : std::wstring{}; - impl_->path.clear(); + if (!complete && !impl_->path.empty()) { + std::error_code ec; + std::filesystem::rename(impl_->path, impl_->path + L".failed", ec); + if (ec) { + std::lock_guard error_lock(impl_->error_mutex); + impl_->error += " Partial output could not be moved to a recovery file."; + } + } + impl_->path.clear(); impl_->guard.reset(); impl_->state = RecordingState::Idle; - return true; + return complete && !failed; } void ManualRecorder::push(encoding::EncodedPacket pkt) { std::lock_guard lk(impl_->mutex); - if (impl_->state == RecordingState::Idle) return; + if (impl_->state == RecordingState::Idle || impl_->state == RecordingState::Failed) return; if (impl_->state == RecordingState::Paused) { if (pkt.stream_index >= 0 && pkt.stream_index <= 6) { @@ -272,14 +288,23 @@ void ManualRecorder::push(encoding::EncodedPacket pkt) if (!impl_->output_failed && !write_packet(impl_, pkt)) { impl_->output_failed = true; + fail("Recording packet write failed. Check the output folder and disk space."); std::fprintf(stderr, "[recording] packet write failed\n"); } } RecordingState ManualRecorder::state() const { - std::lock_guard lk(impl_->mutex); - return impl_->state; + return impl_->state.load(); +} + +void ManualRecorder::fail(std::string error) +{ + { std::lock_guard lk(impl_->error_mutex); impl_->error = std::move(error); } + impl_->state = RecordingState::Failed; +} +std::string ManualRecorder::error() const { + std::lock_guard lk(impl_->error_mutex); return impl_->error; } std::wstring ManualRecorder::current_path() const @@ -294,6 +319,7 @@ const char* state_name(RecordingState state) case RecordingState::Idle: return "idle"; case RecordingState::Recording: return "recording"; case RecordingState::Paused: return "paused"; + case RecordingState::Failed: return "failed"; } return "unknown"; } diff --git a/libs/recording/recording.h b/libs/recording/recording.h index 0f0c948..9961a24 100644 --- a/libs/recording/recording.h +++ b/libs/recording/recording.h @@ -12,6 +12,7 @@ enum class RecordingState { Idle, Recording, Paused, + Failed, }; class ManualRecorder { @@ -33,6 +34,8 @@ class ManualRecorder { bool stop(std::wstring* output_path = nullptr); void push(encoding::EncodedPacket pkt); + void fail(std::string error); + std::string error() const; RecordingState state() const; std::wstring current_path() const; diff --git a/libs/replay-buffer/replay_buffer.cpp b/libs/replay-buffer/replay_buffer.cpp index 2e136b7..0e09c2a 100644 --- a/libs/replay-buffer/replay_buffer.cpp +++ b/libs/replay-buffer/replay_buffer.cpp @@ -3,6 +3,7 @@ #include #include +#include extern "C" { #include @@ -184,7 +185,8 @@ static std::wstring write_clip( const std::vector& audio_params, const std::wstring& out_dir, int duration_sec, - const std::string& container) + const std::string& container, + std::shared_ptr& guard) { if (pkts.empty()) return {}; if (!vsp.tb_den) return {}; @@ -193,6 +195,7 @@ static std::wstring write_clip( CreateDirectoryW(out_dir.c_str(), nullptr); std::wstring path = generate_clip_path(out_dir, duration_sec, container); + guard = std::make_shared(path); std::string path_utf = mux::wcs_to_utf8(path); if (path_utf.empty()) return {}; @@ -303,10 +306,11 @@ void ReplayBuffer::save_clip(std::function cb) cb = std::move(cb)]() mutable { std::wstring result; + std::shared_ptr guard; try { if (!snapshot.empty() && vsp_set) { result = write_clip(std::move(snapshot), vsp, audio_params, - cfg.output_dir, cfg.duration_sec, cfg.container); + cfg.output_dir, cfg.duration_sec, cfg.container, guard); } } catch (...) { OutputDebugStringA("[replay] save worker failed\n"); } try { if (cb) cb(result); } diff --git a/plugins/stream-deck/manifest.json b/plugins/stream-deck/manifest.json index d764b07..19a9b3f 100644 --- a/plugins/stream-deck/manifest.json +++ b/plugins/stream-deck/manifest.json @@ -2,7 +2,7 @@ "Name": "Monolith Recorder", "Author": "fraa2a", "Description": "Control Monolith game recorder from your Stream Deck.", - "Version": "1.4.0", + "Version": "1.4.1.0", "SDKVersion": 2, "Software": { "MinimumVersion": "6.4" diff --git a/plugins/stream-deck/package-lock.json b/plugins/stream-deck/package-lock.json index 8cef93e..4a8f000 100644 --- a/plugins/stream-deck/package-lock.json +++ b/plugins/stream-deck/package-lock.json @@ -1,12 +1,12 @@ { "name": "MonolithIntegration", - "version": "0.4.3", + "version": "1.4.1", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "MonolithIntegration", - "version": "0.4.3", + "version": "1.4.1", "dependencies": { "@elgato/streamdeck": "^2.1.0" }, diff --git a/plugins/stream-deck/package.json b/plugins/stream-deck/package.json index 397fa66..3b91b2f 100644 --- a/plugins/stream-deck/package.json +++ b/plugins/stream-deck/package.json @@ -1,6 +1,6 @@ { "name": "MonolithIntegration", - "version": "1.4.0", + "version": "1.4.1", "private": true, "type": "module", "scripts": { diff --git a/plugins/stream-deck/src/ipc-client.ts b/plugins/stream-deck/src/ipc-client.ts index ff6bddb..edfc0d4 100644 --- a/plugins/stream-deck/src/ipc-client.ts +++ b/plugins/stream-deck/src/ipc-client.ts @@ -78,13 +78,15 @@ export class IpcClient { private onLine(line: string): void { if (!line) return; try { - const msg = JSON.parse(line) as { id?: number; result?: unknown; error?: unknown }; + const msg = JSON.parse(line) as { jsonrpc?: string; id?: number; result?: unknown; error?: unknown }; if (!msg || typeof msg.id !== 'number') return; const handlers = this.pending.get(msg.id); if (!handlers) return; this.pending.delete(msg.id); clearTimeout(handlers[2]); - if (msg.error !== undefined) { + if (msg.jsonrpc !== '2.0' || Object.prototype.hasOwnProperty.call(msg, 'result') === Object.prototype.hasOwnProperty.call(msg, 'error')) { + handlers[1](new Error('IPC: invalid response envelope')); + } else if (msg.error !== undefined) { handlers[1](msg.error); } else { handlers[0](msg.result); @@ -118,7 +120,11 @@ export class IpcClient { async getStatus(): Promise { try { - return (await this.request('get_status')) as RecordingStatus; + const status = await this.request('get_status'); + if (!status || typeof status !== 'object') return null; + const fields = ['recording', 'paused', 'replay_enabled', 'recording_enabled'] as const; + if (!fields.every(key => typeof (status as Record)[key] === 'boolean')) return null; + return status as RecordingStatus; } catch { return null; } diff --git a/scripts/generate-update-manifest.ps1 b/scripts/generate-update-manifest.ps1 index ef564f0..735eba1 100644 --- a/scripts/generate-update-manifest.ps1 +++ b/scripts/generate-update-manifest.ps1 @@ -39,12 +39,14 @@ param( [Parameter(Mandatory)] [string] $BaseUrl, [string] $Tag = "", [string] $NotesUrl = "", - # PEM text of the Ed25519 private key (not a path); empty = unsigned manifest. + # PEM text of the Ed25519 private key (not a path). [string] $PrivateKeyPem = "", - [string] $OutputPath = "update-manifest.json" + [string] $OutputPath = "update-manifest.json", + [string] $PublicKeyBase64 = "GgyaSRupUFn5Omaa90w0H2xDTrqff2DdzRDtbeplvKA=" ) $ErrorActionPreference = "Stop" +if ([string]::IsNullOrWhiteSpace($PrivateKeyPem)) { throw "The release signing key is required." } # Reconstruct canonical PEM from a potentially whitespace-mangled value. # GitHub secrets pasted as a single line lose their newlines; openssl's PEM @@ -74,6 +76,7 @@ function Resolve-Openssl { function Get-EdSignature([string] $FilePath, [string] $openssl) { $keyFile = New-TemporaryFile $sigFile = New-TemporaryFile + $pubFile = New-TemporaryFile try { [System.IO.File]::WriteAllText($keyFile.FullName, (Format-Pem $PrivateKeyPem)) & $openssl pkey -in $keyFile.FullName -noout 2>&1 | Out-Null @@ -88,9 +91,16 @@ function Get-EdSignature([string] $FilePath, [string] $openssl) { if ($sigBytes.Length -ne 64) { throw "Unexpected Ed25519 signature length: $($sigBytes.Length) (want 64)" } + $public = [Convert]::FromBase64String($PublicKeyBase64) + if ($public.Length -ne 32) { throw "Invalid release public key" } + [byte[]] $prefix = 0x30,0x2a,0x30,0x05,0x06,0x03,0x2b,0x65,0x70,0x03,0x21,0x00 + [System.IO.File]::WriteAllBytes($pubFile.FullName, [byte[]]($prefix + $public)) + & $openssl pkeyutl -verify -pubin -keyform DER -inkey $pubFile.FullName -rawin ` + -in $FilePath -sigfile $sigFile.FullName | Out-Null + if ($LASTEXITCODE -ne 0) { throw "Release signature does not match the updater public key." } return [Convert]::ToBase64String($sigBytes) } finally { - Remove-Item $keyFile.FullName, $sigFile.FullName -Force -ErrorAction SilentlyContinue + Remove-Item $keyFile.FullName, $sigFile.FullName, $pubFile.FullName -Force -ErrorAction SilentlyContinue } } @@ -98,33 +108,37 @@ function Get-Component([string] $Key, [string] $Version, [string] $Zip, [string] if (-not (Test-Path $Zip)) { throw "Component zip not found: $Zip" } $item = Get-Item $Zip $sha256 = (Get-FileHash -Algorithm SHA256 $Zip).Hash.ToLowerInvariant() - $edSignature = "" - if ($PrivateKeyPem -ne "") { - $edSignature = Get-EdSignature $Zip $openssl - Write-Host "$Key signed (edSignature: $($edSignature.Substring(0,16))...)" - } else { - Write-Warning "No private key supplied - emitting UNSIGNED manifest entry for $Key. Updater.exe clients with the public key configured will reject it." - } + $edSignature = Get-EdSignature $Zip $openssl + $metadataFile = New-TemporaryFile + try { + $message = "monolith-component-v1`n$Key`n$Version`n$($item.Length)`n$sha256`n" + [System.IO.File]::WriteAllText($metadataFile.FullName, $message, [System.Text.UTF8Encoding]::new($false)) + $metadataSignature = Get-EdSignature $metadataFile.FullName $openssl + } finally { Remove-Item $metadataFile.FullName -Force -ErrorAction SilentlyContinue } return [ordered] @{ version = $Version url = "$BaseUrl/$(Split-Path $Zip -Leaf)" size = $item.Length sha256 = $sha256 + # Compatibility with installed schema-1 clients that expected snake_case. + ed_signature = $edSignature edSignature = $edSignature + metadataSignature = $metadataSignature } } -$openssl = $null -if ($PrivateKeyPem -ne "") { $openssl = Resolve-Openssl } +$openssl = Resolve-Openssl +$publishedAt = (Get-Date).ToUniversalTime().ToString("yyyy-MM-dd'T'HH:mm:ss'Z'", [System.Globalization.CultureInfo]::InvariantCulture) $manifest = [ordered] @{ schema = 1 - publishedAt = (Get-Date).ToUniversalTime().ToString("yyyy-MM-dd'T'HH:mm:ss'Z'", - [System.Globalization.CultureInfo]::InvariantCulture) + publishedAt = $publishedAt release = [ordered] @{ tag = $Tag notesUrl = $NotesUrl + notes_url = $NotesUrl } + published_at = $publishedAt components = [ordered] @{ engine = Get-Component "engine" $EngineVersion $EngineZip $openssl ui = Get-Component "ui" $UiVersion $UiZip $openssl diff --git a/tests/logging/CMakeLists.txt b/tests/logging/CMakeLists.txt new file mode 100644 index 0000000..a47a746 --- /dev/null +++ b/tests/logging/CMakeLists.txt @@ -0,0 +1,10 @@ +cmake_minimum_required(VERSION 3.20) +project(monolith_logging_tests LANGUAGES CXX) +set(CMAKE_CXX_STANDARD 23) +enable_testing() +find_package(Threads REQUIRED) +add_executable(log_writer_test log_writer_test.cpp ../../libs/logging/logging.cpp) +target_include_directories(log_writer_test PRIVATE ../../libs win32-shim) +target_compile_options(log_writer_test PRIVATE -Wall -Wextra -Wpedantic) +target_link_libraries(log_writer_test PRIVATE Threads::Threads) +add_test(NAME log_writer COMMAND log_writer_test) diff --git a/tests/logging/log_writer_test.cpp b/tests/logging/log_writer_test.cpp new file mode 100644 index 0000000..766a631 --- /dev/null +++ b/tests/logging/log_writer_test.cpp @@ -0,0 +1,66 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static std::string read(const std::filesystem::path& path) { + std::ifstream in(path); + return std::string(std::istreambuf_iterator(in), {}); +} + +int main() { + namespace fs = std::filesystem; + auto root = fs::temp_directory_path() / ("monolith-log-" + std::to_string( + std::chrono::steady_clock::now().time_since_epoch().count())); + fs::create_directories(root); + auto capture = root / "stderr.txt"; + FILE* output = std::fopen(capture.c_str(), "wb"); + assert(output); + const int old_stderr = dup(fileno(stderr)); + assert(old_stderr >= 0 && dup2(fileno(output), fileno(stderr)) >= 0); + logging::init(false, (root / "missing").wstring()); + logging::log_error("test", "error-details-must-survive-unavailable-file"); + logging::init(false, root.wstring()); + { + logging::LogWriter writer("/dev/full"); + assert(writer.write("error-details-must-survive-flush-failure\n")); + } + { + logging::LogWriter writer("/dev/full"); + assert(writer.write(std::string(8192, 'x') + "error-details-must-survive-write-failure\n")); + } + std::fflush(stderr); + assert(dup2(old_stderr, fileno(stderr)) >= 0); + close(old_stderr); + std::fclose(output); + const auto fallback = read(capture); + assert(fallback.find("error-details-must-survive-unavailable-file") != std::string::npos); + assert(fallback.find("error-details-must-survive-flush-failure") != std::string::npos); + assert(fallback.find("error-details-must-survive-write-failure") != std::string::npos); + logging::log("test", "verbose-must-not-appear"); + logging::log_error("test", "error-must-persist"); + logging::init(false, (root / "unused").wstring()); + const auto logged = read(root / "monolith.log"); + assert(logged.find("error-must-persist") != std::string::npos); + assert(logged.find("verbose-must-not-appear") == std::string::npos); + fs::create_directories(root / "rotation"); + { + logging::LogWriter writer(root / "rotation" / "monolith.log", 64, 3, 4096); + for (int i = 0; i < 12; ++i) + assert(writer.write("record-" + std::to_string(i) + "-abcdefghijk\n")); + } + assert(fs::exists(root / "rotation" / "monolith.log.1")); + assert(!fs::exists(root / "rotation" / "monolith.log.4")); + for (const auto& file : fs::directory_iterator(root / "rotation")) assert(file.file_size() <= 64); + assert(read(root / "rotation" / "monolith.log").find("record-11-") != std::string::npos); + { + logging::LogWriter writer(root / "bounded.log", 64, 3, 0); + assert(!writer.write("rejected\n")); + } + fs::remove_all(root); +} diff --git a/tests/logging/win32-shim/windows.h b/tests/logging/win32-shim/windows.h new file mode 100644 index 0000000..0843769 --- /dev/null +++ b/tests/logging/win32-shim/windows.h @@ -0,0 +1,12 @@ +#pragma once +#include +#include +struct SYSTEMTIME { unsigned short wYear, wMonth, wDay, wHour, wMinute, wSecond; }; +inline void GetSystemTime(SYSTEMTIME* out) { + auto time = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now()); + std::tm utc{}; gmtime_r(&time, &utc); + *out = {static_cast(1900 + utc.tm_year), static_cast(1 + utc.tm_mon), + static_cast(utc.tm_mday), static_cast(utc.tm_hour), + static_cast(utc.tm_min), static_cast(utc.tm_sec)}; +} +inline void OutputDebugStringA(const char*) {} diff --git a/tests/phase1/CMakeLists.txt b/tests/phase1/CMakeLists.txt index ae07d9d..e2977e9 100644 --- a/tests/phase1/CMakeLists.txt +++ b/tests/phase1/CMakeLists.txt @@ -32,3 +32,7 @@ add_executable(bounded_worker_test bounded_worker_test.cpp) target_include_directories(bounded_worker_test PRIVATE ../../libs) target_link_libraries(bounded_worker_test PRIVATE Threads::Threads) add_test(NAME bounded_worker COMMAND bounded_worker_test) + +add_executable(segment_session_test segment_session_test.cpp) +target_include_directories(segment_session_test PRIVATE ../../libs) +add_test(NAME segment_session COMMAND segment_session_test) diff --git a/tests/phase1/segment_session_test.cpp b/tests/phase1/segment_session_test.cpp new file mode 100644 index 0000000..ae7b32a --- /dev/null +++ b/tests/phase1/segment_session_test.cpp @@ -0,0 +1,33 @@ +#include +#include +#include +#ifndef _WIN32 +#include +#include +#endif +int main() { + namespace fs = std::filesystem; + auto root = fs::temp_directory_path() / "monolith-session-regression"; + fs::remove_all(root); fs::create_directories(root); + { + disk_segments::SessionDirectory live; assert(live.create(root)); + auto path = live.path(); std::ofstream(path / "seg_0.mkv") << "media"; + assert(disk_segments::SessionDirectory::reclaim(root)); assert(fs::exists(path / "seg_0.mkv")); + } +#ifndef _WIN32 + const auto child = fork(); assert(child >= 0); + if (child == 0) { + disk_segments::SessionDirectory dead; if (!dead.create(root)) _exit(2); + std::ofstream(dead.path() / "seg_1.mp4") << "orphan"; + std::ofstream(dead.path() / "personal.txt") << "keep"; _exit(0); + } + int status = 0; waitpid(child, &status, 0); assert(status == 0); + assert(disk_segments::SessionDirectory::reclaim(root)); bool foreign = false; + for (const auto& item : fs::recursive_directory_iterator(root)) { + assert(item.path().filename() != "seg_1.mp4"); + if (item.path().filename() == "personal.txt") foreign = true; + } + assert(foreign); +#endif + fs::remove_all(root); +} diff --git a/tests/phase2/encoding_test.cpp b/tests/phase2/encoding_test.cpp index 1d846a7..c5cdc66 100644 --- a/tests/phase2/encoding_test.cpp +++ b/tests/phase2/encoding_test.cpp @@ -30,6 +30,20 @@ int main() { video.push_bgra(bgra.data(), 64 * 4, 64, 64); video.flush(); CHECK(packets > 0); video.close(); + encoding::AudioEncoder audio; + encoding::AudioEncoder::Config acfg; + std::vector audio_dts; + CHECK(audio.open(acfg, [&](auto p) { audio_dts.push_back(p.dts_usec); })); + std::vector pcm(4800 * 2, 0.25f); + audio.push_pcm(reinterpret_cast(pcm.data()), static_cast(pcm.size() * 4), + 48000, 2, 32, true, 600000000); + audio.close(); CHECK(!audio_dts.empty() && audio_dts.front() > 599000000); + audio_dts.clear(); + CHECK(audio.open(acfg, [&](auto p) { audio_dts.push_back(p.dts_usec); })); + audio.push_pcm(reinterpret_cast(pcm.data()), static_cast(pcm.size() * 4), + 48000, 2, 32, true, 700000000); + audio.close(); CHECK(!audio_dts.empty() && audio_dts.front() > 699000000); + encoding::TrackMixer mixer; CHECK(!mixer.open(48000, 65, {})); std::promise called; diff --git a/tests/phase2/media_test.cpp b/tests/phase2/media_test.cpp index fc2de50..21451a5 100644 --- a/tests/phase2/media_test.cpp +++ b/tests/phase2/media_test.cpp @@ -180,7 +180,20 @@ int main(int argc, char** argv) { recorder.push(*first_video); fail_write = false; recorded = L"stale"; - CHECK(recorder.stop(&recorded) && recorded.empty()); + CHECK(recorder.state() == recording::RecordingState::Failed); + CHECK(!recorder.error().empty()); + CHECK(!recorder.stop(&recorded) && recorded.empty()); + recorder.set_audio_params(std::vector{}); + CHECK(recorder.start((dir/"late-track").wstring(), "mp4")); + recorder.push(*first_video); recorder.set_audio_params(media.audio); + for (const auto& p : media.packets) if (&p != &*first_video) recorder.push(p); + CHECK(recorder.state() == recording::RecordingState::Recording); + CHECK(recorder.stop(&recorded) && !recorded.empty()); decode(recorded); + CHECK(recorder.start((dir/"partial-recordings").wstring(), "mp4")); + for (const auto& p : media.packets) recorder.push(p); + recorder.fail("Capture target closed"); + CHECK(!recorder.stop(&recorded) && !recorded.empty()); decode(recorded); + CHECK(!recorder.error().empty()); const std::wstring long_folder(300, L'a'); CHECK(recorder.start(long_folder, "mkv")); CHECK(recorder.current_path().size() > 300); CHECK(recorder.stop()); diff --git a/tests/rust/Cargo.toml b/tests/rust/Cargo.toml index 7e2dd64..f007bbb 100644 --- a/tests/rust/Cargo.toml +++ b/tests/rust/Cargo.toml @@ -16,7 +16,7 @@ sha2 = "0.10" ed25519-dalek = "2" [target.'cfg(windows)'.dependencies] -windows = { version = "0.58", features = ["Win32_Foundation", "Win32_Security", "Win32_UI_WindowsAndMessaging", "Win32_System_Threading", "Win32_Storage_FileSystem", "Win32_Networking_WinHttp"] } +windows = { version = "0.58", features = ["Win32_Foundation", "Win32_Security", "Win32_UI_WindowsAndMessaging", "Win32_System_Threading", "Win32_System_Diagnostics_ToolHelp", "Win32_Storage_FileSystem", "Win32_Networking_WinHttp"] } [features] default = ["catalogs"] diff --git a/tests/rust/src/host_tests.rs b/tests/rust/src/host_tests.rs new file mode 100644 index 0000000..3e522a1 --- /dev/null +++ b/tests/rust/src/host_tests.rs @@ -0,0 +1,103 @@ +use crate::{clip_catalog, collections, paths, settings_store}; +use rusqlite::Connection; +use serde_json::json; +use std::fs; + +#[test] +fn memberships_survive_missing_media_and_reject_reused_ids_and_catalogs() { + let _guard = crate::CATALOG_ENV_LOCK + .lock() + .unwrap_or_else(|err| err.into_inner()); + let root = std::env::temp_dir().join(format!("monolith-host-{}", std::process::id())); + let _ = fs::remove_dir_all(&root); + fs::create_dir_all(&root).unwrap(); + std::env::set_var("LOCALAPPDATA", &root); + let clips = root.join("clips"); + fs::create_dir_all(&clips).unwrap(); + settings_store::write_config( + &json!({"output":{"clips_directory":clips,"recordings_directory":root.join("recs")}}), + ) + .unwrap(); + let db = Connection::open(clips.join("clips.db")).unwrap(); + db.execute_batch("CREATE TABLE catalog_metadata(key TEXT PRIMARY KEY,value TEXT NOT NULL); + INSERT INTO catalog_metadata VALUES('catalog_uid','catalog-a'); + CREATE TABLE clips(id INTEGER PRIMARY KEY,video_file TEXT,thumbnail_file TEXT,created_at_utc TEXT,duration_seconds REAL,game_process_name TEXT,game_display_name TEXT,favorite INTEGER,title TEXT,clip_uid TEXT NOT NULL); + CREATE TABLE clip_hashtags(clip_id INTEGER,tag TEXT); + INSERT INTO clips VALUES(1,'a.mp4',NULL,'2026-10-08T00:00:00Z',5,NULL,NULL,0,'A','clip-a');").unwrap(); + fs::write(clips.join("a.mp4"), b"video").unwrap(); + fs::create_dir_all(paths::monolith_data_dir()).unwrap(); + let legacy = Connection::open(paths::monolith_data_dir().join("collections.db")).unwrap(); + legacy.execute_batch("CREATE TABLE collections(id INTEGER PRIMARY KEY AUTOINCREMENT,name TEXT NOT NULL,color TEXT NOT NULL,created_at_utc TEXT NOT NULL); + CREATE TABLE collection_clips(collection_id INTEGER NOT NULL REFERENCES collections(id) ON DELETE CASCADE,source TEXT NOT NULL,clip_id INTEGER NOT NULL,added_at_utc TEXT NOT NULL,PRIMARY KEY(collection_id,source,clip_id)); + INSERT INTO collections VALUES(1,'Legacy','','2026-10-08T00:00:00Z'); + INSERT INTO collection_clips VALUES(1,'replay',1,'2026-10-08T00:00:00Z');").unwrap(); + let summaries = collections::list_collections().unwrap(); + assert_eq!(summaries[0].unresolved_count, 1); + assert_eq!(summaries[0].clip_count, 1); + assert!(collections::collection_clips(1).unwrap().is_empty()); + collections::add_clip_to_collection(1, clip_catalog::ClipSource::Replay, 1).unwrap(); + assert_eq!( + collections::list_collections().unwrap()[0].unresolved_count, + 0 + ); + assert_eq!( + collections::collection_memberships(clip_catalog::ClipSource::Replay, 1).unwrap(), + vec![1] + ); + collections::delete_collection(1).unwrap(); + drop(legacy); + let collection = collections::create_collection("Games", "").unwrap(); + collections::add_clip_to_collection(collection, clip_catalog::ClipSource::Replay, 1).unwrap(); + fs::rename(clips.join("a.mp4"), clips.join("moved.mp4")).unwrap(); + assert!(collections::collection_clips(collection) + .unwrap() + .is_empty()); + let members = Connection::open(paths::monolith_data_dir().join("collections.db")).unwrap(); + let count: i64 = members + .query_row("SELECT COUNT(*) FROM collection_clips", [], |r| r.get(0)) + .unwrap(); + assert_eq!( + count, 1, + "a transient missing media file must not remove membership" + ); + fs::rename(clips.join("moved.mp4"), clips.join("a.mp4")).unwrap(); + assert_eq!(collections::collection_clips(collection).unwrap().len(), 1); + db.execute_batch("ALTER TABLE clip_hashtags RENAME TO tags_unavailable;") + .unwrap(); + assert_eq!( + collections::collection_memberships(clip_catalog::ClipSource::Replay, 1).unwrap(), + vec![collection] + ); + db.execute_batch("ALTER TABLE tags_unavailable RENAME TO clip_hashtags;") + .unwrap(); + db.execute_batch("DELETE FROM clips;INSERT INTO clips VALUES(1,'a.mp4',NULL,'2026-10-09T00:00:00Z',5,NULL,NULL,0,'B','clip-b');").unwrap(); + assert!( + collections::collection_clips(collection) + .unwrap() + .is_empty(), + "reused row IDs must not inherit membership" + ); + assert!(collections::add_clip_with_identity( + collection, + clip_catalog::ClipSource::Replay, + 1, + clip_catalog::ClipIdentity { + catalog_uid: "catalog-a".into(), + clip_uid: "clip-a".into() + } + ) + .is_err()); + db.execute_batch( + "UPDATE clips SET clip_uid='clip-a';UPDATE catalog_metadata SET value='catalog-b';", + ) + .unwrap(); + assert!( + collections::collection_clips(collection) + .unwrap() + .is_empty(), + "another catalog must not inherit membership" + ); + drop(members); + drop(db); + fs::remove_dir_all(root).unwrap(); +} diff --git a/tests/rust/src/lib.rs b/tests/rust/src/lib.rs index 8d734c5..fb87a08 100644 --- a/tests/rust/src/lib.rs +++ b/tests/rust/src/lib.rs @@ -31,7 +31,7 @@ mod apply; #[cfg(windows)] #[path = "../../../app/updater/src-tauri/src/http.rs"] mod http; -#[cfg(all(windows, not(feature = "catalogs")))] +#[cfg(not(feature = "catalogs"))] #[path = "../../../app/updater/src-tauri/src/versions.rs"] mod versions; @@ -63,3 +63,25 @@ mod tests; mod ui_rpc; #[path = "../../../app/updater/src-tauri/src/engine_rpc.rs"] mod updater_rpc; + +#[cfg(all(test, feature = "catalogs"))] +mod host_tests; +#[cfg(feature = "catalogs")] +mod engine_rpc { + pub use crate::ui_rpc::*; +} +#[cfg(feature = "catalogs")] +#[path = "../../../app/desktop-ui/src-tauri/src/clip_mutations.rs"] +mod clip_mutations; +#[path = "../../../app/desktop-ui/src-tauri/src/media_assets.rs"] +mod media_assets; +#[cfg(all(test, feature = "catalogs"))] +static CATALOG_ENV_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(()); +#[path = "../../../app/desktop-ui/src-tauri/src/request_pool.rs"] +mod request_pool; +#[path = "../../../app/updater/src-tauri/src/process.rs"] +mod process; + +#[cfg(not(feature = "catalogs"))] +#[path = "../../../app/updater/src-tauri/src/state.rs"] +mod updater_state; diff --git a/tests/rust/src/tests.rs b/tests/rust/src/tests.rs index 4134a56..2eb4a12 100644 --- a/tests/rust/src/tests.rs +++ b/tests/rust/src/tests.rs @@ -11,6 +11,7 @@ fn component() -> manifest::ComponentInfo { size: 1, sha256: "ab".repeat(32), ed_signature: base64::engine::general_purpose::STANDARD.encode([0u8; 64]), + metadata_signature: String::new(), } } @@ -92,7 +93,10 @@ fn archive_rejects_windows_path_aliases_and_traversal() { } #[test] -fn catalogs_preserve_membership_on_errors_and_serialize_bookmarks() { +fn catalogs_preserve_membership_on_errors() { + let _guard = crate::CATALOG_ENV_LOCK + .lock() + .unwrap_or_else(|err| err.into_inner()); let root = std::env::temp_dir().join(format!("monolith-catalogs-{}", std::process::id())); let _ = fs::remove_dir_all(&root); fs::create_dir_all(&root).unwrap(); @@ -154,37 +158,22 @@ fn catalogs_preserve_membership_on_errors_and_serialize_bookmarks() { db.execute_batch( "CREATE TABLE clips (id INTEGER PRIMARY KEY, video_file TEXT, thumbnail_file TEXT, created_at_utc TEXT, duration_seconds REAL, game_process_name TEXT, game_display_name TEXT, - favorite INTEGER, title TEXT); + favorite INTEGER, title TEXT, clip_uid TEXT); + CREATE TABLE catalog_metadata(key TEXT PRIMARY KEY,value TEXT); + INSERT INTO catalog_metadata VALUES('catalog_uid','catalog-tests'); CREATE TABLE clip_hashtags (clip_id INTEGER, tag TEXT); - INSERT INTO clips VALUES (1,'a.mp4',NULL,'2026-10-08T00:00:00Z',5,NULL,NULL,0,'A');", + INSERT INTO clips VALUES (1,'a.mp4',NULL,'2026-10-08T00:00:00Z',5,NULL,NULL,0,'A','clip-tests');", ) .unwrap(); fs::write(clips.join("a.mp4"), b"video").unwrap(); let collection = collections::create_collection("Games", "").unwrap(); collections::add_clip_to_collection(collection, clip_catalog::ClipSource::Replay, 1).unwrap(); assert_eq!(collections::collection_clips(collection).unwrap().len(), 1); - let mut workers = Vec::new(); - for index in 0..8 { - workers.push(std::thread::spawn(move || { - clip_catalog::add_bookmark( - clip_catalog::ClipSource::Replay, - 1, - f64::from(index), - "", - "", - ) - .unwrap(); - })); - } - for worker in workers { - worker.join().unwrap(); - } - let count: i64 = db - .query_row("SELECT COUNT(DISTINCT seq) FROM clip_bookmarks", [], |r| { - r.get(0) - }) - .unwrap(); - assert_eq!(count, 8); + assert!( + clip_catalog::list_bookmarks(clip_catalog::ClipSource::Replay, 1) + .unwrap() + .is_empty() + ); db.execute_batch("ALTER TABLE clips RENAME TO broken;") .unwrap(); assert!(collections::collection_clips(collection).is_err()); diff --git a/tests/stream-deck/ipc-client.test.mjs b/tests/stream-deck/ipc-client.test.mjs index 54d20b4..19b3e26 100644 --- a/tests/stream-deck/ipc-client.test.mjs +++ b/tests/stream-deck/ipc-client.test.mjs @@ -33,7 +33,7 @@ test('IPC handles UTF-8 splits, disconnects, response limits and shutdown', { ti const data = once(peer, 'data'); const reply = client.request('get_status'); const request = JSON.parse((await data)[0].toString()); - const response = Buffer.from(JSON.stringify({ id: request.id, result: 'caffè' }) + '\n'); + const response = Buffer.from(JSON.stringify({ jsonrpc: '2.0', id: request.id, result: 'caffè' }) + '\n'); const split = response.indexOf(Buffer.from('è')) + 1; peer.write(response.subarray(0, split)); await delay(10); @@ -50,7 +50,7 @@ test('IPC handles UTF-8 splits, disconnects, response limits and shutdown', { ti const nextData = once(peer, 'data'); const next = client.request('get_status'); const nextRequest = JSON.parse((await nextData)[0].toString()); - peer.write(JSON.stringify({ id: nextRequest.id, result: 42 }) + '\n'); + peer.write(JSON.stringify({ jsonrpc: '2.0', id: nextRequest.id, result: 42 }) + '\n'); assert.equal(await next, 42); peer.write('x'.repeat(65537)); await until(() => !client.isConnected()); @@ -69,3 +69,33 @@ test('IPC handles UTF-8 splits, disconnects, response limits and shutdown', { ti await once(server, 'close'); } }); + + +test('IPC rejects malformed envelopes and status objects', async () => { + let peer; + const server = net.createServer(socket => { peer = socket; }); + server.listen(45991, '127.0.0.1'); + await once(server, 'listening'); + const client = new IpcClient(); + try { + client.connect(); + await until(() => client.isConnected() && peer); + for (const fields of [{}, { result: null, error: {} }, { jsonrpc: '1.0', result: true }]) { + const data = once(peer, 'data'); + const reply = client.request('save_replay'); + const rejected = assert.rejects(reply, /invalid.*response/); + const request = JSON.parse((await data)[0].toString()); + peer.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, ...fields }) + '\n'); + await rejected; + } + for (const result of [null, {}, { recording: true }, { recording: true, paused: false, replay_enabled: true, recording_enabled: 'yes' }]) { + const data = once(peer, 'data'); + const reply = client.getStatus(); + const request = JSON.parse((await data)[0].toString()); + peer.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result }) + '\n'); + assert.equal(await reply, null); + } + } finally { + client.destroy(); peer?.destroy(); server.close(); await once(server, 'close'); + } +}); diff --git a/tests/updater/build-spaces.ps1 b/tests/updater/build-spaces.ps1 new file mode 100644 index 0000000..79ab433 --- /dev/null +++ b/tests/updater/build-spaces.ps1 @@ -0,0 +1,35 @@ +$ErrorActionPreference = 'Stop' +$root = Join-Path ([IO.Path]::GetTempPath()) ('monolith path test ' + [guid]::NewGuid()) +New-Item -ItemType Directory $root | Out-Null +$oldPath = $env:PATH +$oldVcpkg = $env:VCPKG_ROOT +try { + Copy-Item "$PSScriptRoot/../../build.bat" $root + $vcpkg = Join-Path $root 'vcpkg with spaces' + New-Item -ItemType Directory "$vcpkg/scripts/buildsystems" -Force | Out-Null + New-Item -ItemType File "$vcpkg/scripts/buildsystems/vcpkg.cmake" | Out-Null + $env:VCPKG_ROOT = $vcpkg + $env:MONOLITH_BUILD_ARGS = Join-Path $root 'args.txt' + Add-Type -TypeDefinition @' +using System; +using System.IO; +public class CmakeProbe { + public static int Main(string[] args) { + if (Array.IndexOf(args, "-S") >= 0) File.WriteAllLines(Environment.GetEnvironmentVariable("MONOLITH_BUILD_ARGS"), args); + return 0; + } +} +'@ -OutputAssembly "$root/cmake.exe" -OutputType ConsoleApplication + $env:PATH = "$root;$oldPath" + & cmd /c "call `"$root/build.bat`" < NUL" + if ($LASTEXITCODE -ne 0) { throw 'build.bat failed' } + $args = [IO.File]::ReadAllLines($env:MONOLITH_BUILD_ARGS) + if ($args -notcontains "-DCMAKE_TOOLCHAIN_FILE=$vcpkg\scripts\buildsystems\vcpkg.cmake") { throw 'toolchain definition split at spaces' } + $mt = @($args | Where-Object { $_.StartsWith('-DCMAKE_MT:FILEPATH=') }) + if ($mt.Count -ne 1 -or $mt[0] -notmatch 'Program Files') { throw 'SDK definition absent or split at spaces' } +} finally { + $env:PATH = $oldPath + $env:VCPKG_ROOT = $oldVcpkg + Remove-Item Env:MONOLITH_BUILD_ARGS -ErrorAction SilentlyContinue + Remove-Item $root -Recurse -Force +} diff --git a/tests/updater/manifest-contract.ps1 b/tests/updater/manifest-contract.ps1 new file mode 100644 index 0000000..f9ad7f1 --- /dev/null +++ b/tests/updater/manifest-contract.ps1 @@ -0,0 +1,39 @@ +$ErrorActionPreference = 'Stop' +$root = Join-Path ([IO.Path]::GetTempPath()) ([guid]::NewGuid().ToString()) +New-Item -ItemType Directory $root | Out-Null +try { + $key = Join-Path $root 'private.pem' + $pub = Join-Path $root 'public.der' + & openssl genpkey -algorithm ED25519 -out $key + if ($LASTEXITCODE -ne 0) { throw 'test key generation failed' } + & openssl pkey -in $key -pubout -outform DER -out $pub + if ($LASTEXITCODE -ne 0) { throw 'test public key extraction failed' } + $bytes = [IO.File]::ReadAllBytes($pub) + $public = [Convert]::ToBase64String($bytes[($bytes.Length-32)..($bytes.Length-1)]) + $zip = Join-Path $root 'payload.zip' + $payload = Join-Path $root 'payload' + New-Item -ItemType Directory $payload | Out-Null + [IO.File]::WriteAllBytes((Join-Path $payload 'sample.bin'), [byte[]](1,2,3,4)) + [IO.Compression.ZipFile]::CreateFromDirectory($payload, $zip) + $output = Join-Path $root 'manifest.json' + $args = @{ EngineVersion='1.2.3'; UiVersion='2.3.4'; UpdaterVersion='3.4.5'; EngineZip=$zip; UiZip=$zip; UpdaterZip=$zip; BaseUrl='https://example.com/releases'; OutputPath=$output } + $failed = $false + try { & "$PSScriptRoot/../../scripts/generate-update-manifest.ps1" @args -PrivateKeyPem '' } catch { $failed = $true } + if (-not $failed -or (Test-Path $output)) { throw 'missing signing key published a manifest' } + $failed = $false + try { & "$PSScriptRoot/../../scripts/generate-update-manifest.ps1" @args -PrivateKeyPem 'invalid private key' } catch { $failed = $true } + if (-not $failed -or (Test-Path $output)) { throw 'invalid signing key published a manifest' } + $pem = [IO.File]::ReadAllText($key) + $failed = $false + try { & "$PSScriptRoot/../../scripts/generate-update-manifest.ps1" @args -PrivateKeyPem $pem } catch { $failed = $true } + if (-not $failed -or (Test-Path $output)) { throw 'wrong signing key published a manifest' } + & "$PSScriptRoot/../../scripts/generate-update-manifest.ps1" @args -PrivateKeyPem $pem -PublicKeyBase64 $public + $env:MONOLITH_GENERATED_MANIFEST = $output + $env:MONOLITH_TEST_PUBLIC_KEY = $public + $env:MONOLITH_TEST_PAYLOAD = $zip + cargo test --locked --no-default-features --manifest-path "$PSScriptRoot/../rust/Cargo.toml" -- --ignored --exact manifest::tests::generated_release_contract + if ($LASTEXITCODE -ne 0) { throw 'generated manifest rejected by production parser' } +} finally { + Remove-Item $root -Recurse -Force + Remove-Item Env:MONOLITH_GENERATED_MANIFEST, Env:MONOLITH_TEST_PUBLIC_KEY, Env:MONOLITH_TEST_PAYLOAD -ErrorAction SilentlyContinue +} diff --git a/tests/updater/state-stream.test.mjs b/tests/updater/state-stream.test.mjs new file mode 100644 index 0000000..df29a56 --- /dev/null +++ b/tests/updater/state-stream.test.mjs @@ -0,0 +1,41 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { attachState } from '../../app/updater/ui/src/state-stream.ts'; + +test('listener precedes snapshot and late snapshots cannot replace terminal events', async () => { + let event; + let resolveSnapshot; + let detached = false; + const seen = []; + const stop = attachState( + async receive => { event = receive; return () => { detached = true; }; }, + () => { assert.ok(event); return new Promise(resolve => { resolveSnapshot = resolve; }); }, + value => seen.push(value.phase), + ); + await Promise.resolve(); + event({ revision: 3, phase: 'done' }); + resolveSnapshot({ revision: 2, phase: 'downloading' }); + await Promise.resolve(); + await Promise.resolve(); + assert.deepEqual(seen, ['done']); + event({ revision: 1, phase: 'available' }); + assert.deepEqual(seen, ['done']); + stop(); + assert.equal(detached, true); + event({ revision: 4, phase: 'failed' }); + assert.deepEqual(seen, ['done']); +}); + +test('unmount before listener registration cleans up without reading snapshot', async () => { + let resolveListener; + let detached = false; + const stop = attachState( + () => new Promise(resolve => { resolveListener = resolve; }), + () => { throw new Error('snapshot after disposal'); }, + () => { throw new Error('event after disposal'); }, + ); + stop(); + resolveListener(() => { detached = true; }); + await Promise.resolve(); + assert.equal(detached, true); +}); From 0cd89aef841f91c0336f084fda108b6bebb5fb0e Mon Sep 17 00:00:00 2001 From: fraa2a Date: Fri, 9 Oct 2026 16:53:51 +0200 Subject: [PATCH 03/14] chore: bump modified components for audit corrections --- CMakeLists.txt | 2 +- app/desktop-ui/src-tauri/Cargo.lock | 2 +- app/desktop-ui/src-tauri/Cargo.toml | 2 +- app/desktop-ui/src-tauri/tauri.conf.json | 2 +- app/updater/src-tauri/Cargo.lock | 2 +- app/updater/src-tauri/Cargo.toml | 2 +- app/updater/src-tauri/tauri.conf.json | 2 +- 7 files changed, 7 insertions(+), 7 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 1ab55b8..c68ac10 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -8,7 +8,7 @@ if(DEFINED ENV{VCPKG_ROOT} AND NOT DEFINED CMAKE_TOOLCHAIN_FILE) CACHE STRING "vcpkg toolchain file") endif() -project(monolith VERSION 1.6.2 LANGUAGES CXX) +project(monolith VERSION 1.6.3 LANGUAGES CXX) # Engine version - the engine component of the component updater (the ui and # updater components carry their own versions in their tauri.conf.json). diff --git a/app/desktop-ui/src-tauri/Cargo.lock b/app/desktop-ui/src-tauri/Cargo.lock index 3f92590..0158998 100644 --- a/app/desktop-ui/src-tauri/Cargo.lock +++ b/app/desktop-ui/src-tauri/Cargo.lock @@ -2077,7 +2077,7 @@ dependencies = [ [[package]] name = "monolith-ui" -version = "1.5.0" +version = "1.5.1" dependencies = [ "base64 0.22.1", "png 0.17.16", diff --git a/app/desktop-ui/src-tauri/Cargo.toml b/app/desktop-ui/src-tauri/Cargo.toml index cc8b6e5..7fc5c7d 100644 --- a/app/desktop-ui/src-tauri/Cargo.toml +++ b/app/desktop-ui/src-tauri/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "monolith-ui" -version = "1.5.0" +version = "1.5.1" edition = "2021" [build-dependencies] diff --git a/app/desktop-ui/src-tauri/tauri.conf.json b/app/desktop-ui/src-tauri/tauri.conf.json index 49d1b0b..d403c7f 100644 --- a/app/desktop-ui/src-tauri/tauri.conf.json +++ b/app/desktop-ui/src-tauri/tauri.conf.json @@ -1,7 +1,7 @@ { "$schema": "https://schema.tauri.app/config/2", "productName": "Monolith.UI", - "version": "1.5.0", + "version": "1.5.1", "identifier": "dev.scatola.monolith.ui", "build": { "frontendDist": "../dist", diff --git a/app/updater/src-tauri/Cargo.lock b/app/updater/src-tauri/Cargo.lock index 51f5ac9..53c93e8 100644 --- a/app/updater/src-tauri/Cargo.lock +++ b/app/updater/src-tauri/Cargo.lock @@ -2161,7 +2161,7 @@ dependencies = [ [[package]] name = "monolith-updater" -version = "1.0.2" +version = "1.0.3" dependencies = [ "base64 0.22.1", "ed25519-dalek", diff --git a/app/updater/src-tauri/Cargo.toml b/app/updater/src-tauri/Cargo.toml index f2c2ce6..da4ccf4 100644 --- a/app/updater/src-tauri/Cargo.toml +++ b/app/updater/src-tauri/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "monolith-updater" -version = "1.0.2" +version = "1.0.3" edition = "2021" [build-dependencies] diff --git a/app/updater/src-tauri/tauri.conf.json b/app/updater/src-tauri/tauri.conf.json index bb1b3ee..a44e8c1 100644 --- a/app/updater/src-tauri/tauri.conf.json +++ b/app/updater/src-tauri/tauri.conf.json @@ -1,7 +1,7 @@ { "$schema": "https://schema.tauri.app/config/2", "productName": "Updater", - "version": "1.0.2", + "version": "1.0.3", "identifier": "dev.scatola.monolith.updater", "build": { "frontendDist": "../dist", From fbc2c857ecd42f84abfde0b7c4615d5f2d4ab056 Mon Sep 17 00:00:00 2001 From: fraa2a Date: Fri, 9 Oct 2026 16:53:56 +0200 Subject: [PATCH 04/14] docs: record audit scope, contracts and verification limits --- docs/DECISIONS.md | 24 +++++++++++ docs/audit/2026-10-09-fixes.md | 72 ++++++++++++++++++++++++++++++++ docs/handover/ACTIVE_HANDOVER.md | 11 ++++- 3 files changed, 106 insertions(+), 1 deletion(-) create mode 100644 docs/audit/2026-10-09-fixes.md diff --git a/docs/DECISIONS.md b/docs/DECISIONS.md index 4c3a406..2554b0f 100644 --- a/docs/DECISIONS.md +++ b/docs/DECISIONS.md @@ -329,3 +329,27 @@ Replace the independent component swaps with one app-local transaction containin Recover before querying installed versions. Preserve unexpectedly changed files and surface recovery errors. Keep transaction backups until commit or complete rollback; retry cleanup if loaded images prevent removal. Read installed updater version resources and report engine spawn errors. Do not start a restored engine while recovery is still pending. This provides recoverable disk installation, not instantaneous multi-file visibility or certified power-loss durability. A missing updater executable between its two moves can require a retained updater/reinstallation to invoke recovery. Stable file identity, concurrent external writers, engine readiness and clean Windows installer execution remain separate work. See `docs/audit/2026-10-08-followup.md` for test evidence. + +## ADR-0022: Owned recording work and stable media identity + +Date: 2026-10-09 + +The engine remains the only media/catalog writer. Persistent catalog and clip UIDs guard identity; media revisions guard duration, thumbnail and timeline updates. Collections quarantine ambiguous legacy membership rather than attaching it to reused IDs. Read-only UI hydration uses one settings-folder snapshot for both database and media paths. + +Trim uses catalog mutation locking and a recoverable operation journal covering media, metadata and bookmark retiming. Reconciliation preserves unavailable rows and excludes owned/temporary media. Publication ownership spans catalog insertion and final bookmark batches, rejecting competing destructive edits until complete. + +Shared capture epochs, bounded encoded-write jobs, an owned lifecycle worker and session bookmark recovery batches replace global session state and synchronous producer writes. Optional audio arriving after the mux header waits for the next session. Failed finalization preserves valid partial media, exposes an error and blocks a new session until retained work is resolved. Replay callbacks, catalog tasks and logging drain before teardown. + +The UI stages thumbnail bytes in a fixed upload directory and sends an opaque token over RPC. The engine validates size, PNG signature, identity and revision before publication. Media reads use a bounded custom protocol checking current canonical roots rather than an accumulating asset scope. + +This preserves the native engine and Tauri sidecars. Queue bounds and recovery journals do not imply unlimited throughput, instantaneous multi-resource atomicity or certified power-loss durability. + +## ADR-0023: Signed release identity and stable updater recovery + +Date: 2026-10-09 + +Retain legacy ZIP signatures and field compatibility. Add a separate Ed25519 signature over exact UTF-8 `monolith-component-v1\n{key}\n{version}\n{size}\n{lowercase_sha256}\n`. New clients require the identity signature, validate payload version resources and reject downgrades. Release generation without a valid matching key fails; verification streams bounded chunks and observes cancellation. + +Sync a stable updater recovery copy outside the replacement plan before journaling. The engine detects pending recovery and launches that entry. Retain actual engine process handles, resolve executable path aliases consistently, and require version readiness from a live restarted child. Serialize cancellation against Applying and order snapshots/events using monotonic revisions. + +Old clients accept the compatible manifest, but their first upgrade still runs old transaction code. New recovery cannot fix an interruption before the stable entry has been installed; reinstall remains the migration fallback. Clean Windows installation and power-loss tests remain release requirements. diff --git a/docs/audit/2026-10-09-fixes.md b/docs/audit/2026-10-09-fixes.md new file mode 100644 index 0000000..df1c9f1 --- /dev/null +++ b/docs/audit/2026-10-09-fixes.md @@ -0,0 +1,72 @@ +# Audit corrections + +Baseline: `2e8c4ec1616215344b968a5f09a004cf9df6d494`. PR: https://github.com/fraa2a/Monolith/pull/8. + +This is the implementation record for the user-approved audit. Each finding has a concrete correction or an explicitly bounded mitigation. Final verification is recorded in the PR and active handover. Portable tests and browser fixtures do not certify Windows hardware, WebView2 playback, clean installation or power-loss durability. + +| Finding | Implementation and limit | +| --- | --- | +| M01 | Recording pipeline initialization no longer depends on replay preferences; establish session ownership before starting producers. | +| M02 | Shared QPC capture epoch for audio and video. Long-session hardware drift remains a runtime check. | +| M03 | Capture target changes restart WGC; Closed callbacks invalidate capture without retaining a destroyed owner. | +| M04 | Retain desired settings/targets during recording and apply them after completion. | +| M05 | Bounded owned encoded-write and lifecycle workers; pause/stop avoid blocked writer locks on the tray. Drain replay callbacks and catalog tasks before teardown. Hardware latency measurements remain pending. | +| M06 | Recover audio invalidation/default endpoint changes. Optional tracks recovered after mux-header creation are deferred to the next session. | +| M07 | Owned disk-session locks; reclaim abandoned recognizable segments only, preserving foreign files. | +| M08 | Expose writer failure in operational status. Preserve valid finalized partial media while reporting failure. Retained finalization blocks a new session until retry succeeds. | +| S01 | Validate trim root containment and file identity before replacement. | +| S02 | Serialize trim under catalog mutation locking with operation-specific temporary files. | +| S03 | Recoverable trim journal covers media, metadata and bookmark retiming. This is recovery, not instantaneous filesystem/SQLite atomicity. | +| S04 | Session-owned bounded bookmark batches and recovery sidecars, including failed finalization/shutdown. Ownership excludes destructive edits during publication. | +| S05 | Persistent catalog/clip membership UIDs; ambiguous legacy entries remain unresolved until explicitly re-added, avoiding reused-ID attachment. | +| S06 | Preserve catalog rows when enumeration/access fails. | +| S07 | Reconciliation excludes active, owned and temporary media. | +| S08 | Read-only collection hydration does not prune transiently missing membership. | +| S09 | Engine-only media/catalog mutation RPCs. Stable identity and media revision guards reject stale writes/timeline edits. Offline browsing remains available. | +| S10 | First-request deadline expires silent IPC clients. Persistent useful clients remain supported; no loopback authentication is added. | +| F01 | Flush pending settings on panel, title-bar and native close; save errors retain the window. | +| F02 | Shared serialized settings draft across Settings and title-bar actions. | +| F03 | Identity-based selection, with path/time fallback for legacy empty UIDs. | +| F04 | Display operational capture/encoder/buffer readiness instead of saved preferences. | +| F05 | Focused inputs and controls retain arrow-key ownership. | +| F06 | Publish returned thumbnail paths and refresh cards. | +| F07 | Explicit unavailable-audio-track API message and file-opening fallback. Native multitrack support remains WebView2-dependent. | +| F08 | Catalog events refresh open collections. | +| F09 | Reuse valid metadata and limit viewport-driven repairs to two probes. Database pagination/full virtualization remain deferred optimizations. | +| F10 | Accessible labels for settings inputs, switches and actions. | +| F11 | Reapply Favorites filtering after unfavorite. | +| F12 | Restore prior maximized state after fullscreen. | +| U01 | Actual PowerShell producer and Rust consumers share a tested manifest contract with legacy field compatibility. | +| U02 | Retain matching process handles, wait for actual exit and require version readiness from a live restarted child. Canonicalize both process paths, including Windows aliases. | +| U03 | Sync a stable recovery updater before journaling; engine discovers pending recovery. The old updater's first migration cannot retroactively acquire this protection, so installer recovery remains its fallback. | +| U04 | Serialize cancellation against Applying and check cancellation during hashing. | +| U05 | Quote build paths; exercise a build directory containing spaces. | +| U06 | Additional Ed25519 envelope binds key/version/size/digest; validate payload version resources and reject downgrades. Retain legacy ZIP signatures for old clients. | +| U07 | Reject missing, malformed or mismatched release keys and verify generated signatures. No release publication is part of this task. | +| U08 | Bounded streaming hashing/signature verification with cancellation. | +| U09 | Strict Stream Deck JSON-RPC result/error and request-ID validation. | +| U10 | Monotonic updater state revisions; register event listeners before snapshot retrieval. | +| Q01 | Bounded asynchronous runtime-rotated logger, drained on shutdown; preserve actual error text when file output fails. | +| Q02 | Bounded custom media protocol checks current canonical roots per request; remove accumulating asset scopes and obsolete protocol feature. Retry transient thumbnail saturation. Windows range playback needs a smoke test. | +| Q03 | Direct compact membership lookup instead of hydrating every collection. | +| Q04 | Extract focused worker, lifecycle, bookmark, ownership and request-pool responsibilities. This is not a complete rewrite of the recorder entrypoint. | +| Q05 | Current architecture, decisions, test guidance and active handover; historical handover entries remain historical. | + +## Verification commands + +```sh +for suite in phase1 phase2 u6 logging; do + cmake -S "tests/$suite" -B "build-tests/$suite" -DCMAKE_CXX_FLAGS=-Werror + cmake --build "build-tests/$suite" --parallel 2 + ctest --test-dir "build-tests/$suite" --output-on-failure +done +cargo test --locked --manifest-path tests/rust/Cargo.toml +cargo test --locked --no-default-features --manifest-path tests/rust/Cargo.toml +cargo check --locked --tests --no-default-features --target x86_64-pc-windows-msvc --manifest-path tests/rust/Cargo.toml +python3 scripts/check-text.py +git diff --check +``` + +Both frontends run TypeScript and Vite checks. Chromium executes the desktop layout/interaction and audit fixtures. Stream Deck uses its production build and real socket tests. PowerShell produces a signed release fixture consumed by Rust with a test key. Windows CI additionally exercises real process exit, running-image replacement, recovery launch and native compilation. + +Before release, execute real WGC target switching, audio/device recovery, long-session synchronization, slow-disk shutdown, WebView2 range/multitrack playback, close/save failure handling and a clean-VM install/update smoke test. Journal recovery does not establish certified power-loss durability. diff --git a/docs/handover/ACTIVE_HANDOVER.md b/docs/handover/ACTIVE_HANDOVER.md index ec84a7e..62836a1 100644 --- a/docs/handover/ACTIVE_HANDOVER.md +++ b/docs/handover/ACTIVE_HANDOVER.md @@ -1,6 +1,15 @@ # Active Handover -Updated: 2026-10-08 +Updated: 2026-10-09 + +## Current checkpoint: audit correction PR #8 in progress + +- User authorized the complete 2026-10-09 audit corrections in one PR: https://github.com/fraa2a/Monolith/pull/8. Branch `fix/audit-errors`, baseline `2e8c4ec1616215344b968a5f09a004cf9df6d494`. No merge or release is requested. +- Remote checkpoint `3b77da296507f6f68b0888efeb9da9f3158b8d0a` preserves initial engine helpers, host/UI/updater and logger changes. Core CI passed on that checkpoint. Windows CI exposed asymmetric process-path normalization and obsolete Tauri protocol-asset configuration; followups are being integrated. +- Local worktrees were reset twice by the execution environment before final integration was published. Recover from the remote branch; commit and push each subsequent correction promptly. Do not infer final verification from tests of an earlier local tree. +- The 45-finding implementation scope and runtime limits are in `docs/audit/2026-10-09-fixes.md`. Decisions ADR-0022/0023 describe changed contracts. Engine 1.6.3, UI 1.5.1, updater 1.0.3, Stream Deck 1.4.1. +- Final native mutation routing, storage journal and recording lifecycle integration are pending reconstruction and fresh checks at this checkpoint. Keep PR draft until final review and verification are assessed. +- Actual Windows capture/audio hardware, WebView2 media behavior, power loss and clean installation remain release checks. Historical entries below do not override this checkpoint or the user's current authorization. ## Current checkpoint: screenshot-based desktop UI redesign From 5db408e03b38456fe7d94e662a05208882761547 Mon Sep 17 00:00:00 2001 From: fraa2a Date: Fri, 9 Oct 2026 16:54:01 +0200 Subject: [PATCH 05/14] Retain finalization state across publication retries --- libs/recording/finalization.h | 22 ++++++++++++++++++++++ tests/phase1/CMakeLists.txt | 4 ++++ tests/phase1/finalization_test.cpp | 19 +++++++++++++++++++ 3 files changed, 45 insertions(+) create mode 100644 libs/recording/finalization.h create mode 100644 tests/phase1/finalization_test.cpp diff --git a/libs/recording/finalization.h b/libs/recording/finalization.h new file mode 100644 index 0000000..e5eb438 --- /dev/null +++ b/libs/recording/finalization.h @@ -0,0 +1,22 @@ +#pragma once +#include +#include +namespace recording { +struct FinalizationState { + std::wstring path; + bool finalized = false; + bool published = false; + bool pending() const { return !published; } +}; +template +void finalize_once(FinalizationState& state, Stop stop, Publish publish) { + if (!state.finalized) { + state.path = stop(); + state.finalized = true; + } + if (!state.published) { + publish(state.path); + state.published = true; + } +} +} diff --git a/tests/phase1/CMakeLists.txt b/tests/phase1/CMakeLists.txt index e2977e9..fa27165 100644 --- a/tests/phase1/CMakeLists.txt +++ b/tests/phase1/CMakeLists.txt @@ -36,3 +36,7 @@ add_test(NAME bounded_worker COMMAND bounded_worker_test) add_executable(segment_session_test segment_session_test.cpp) target_include_directories(segment_session_test PRIVATE ../../libs) add_test(NAME segment_session COMMAND segment_session_test) + +add_executable(finalization_test finalization_test.cpp) +target_include_directories(finalization_test PRIVATE ../../libs) +add_test(NAME finalization COMMAND finalization_test) diff --git a/tests/phase1/finalization_test.cpp b/tests/phase1/finalization_test.cpp new file mode 100644 index 0000000..0381e79 --- /dev/null +++ b/tests/phase1/finalization_test.cpp @@ -0,0 +1,19 @@ +#include +#include +#include +int main() { + recording::FinalizationState state; + int stops = 0, attempts = 0; + auto stop = [&] { ++stops; return std::wstring(L"session.mkv"); }; + auto publish = [&](const std::wstring& path) { + assert(path == L"session.mkv"); + if (++attempts == 1) throw std::runtime_error("journal unavailable"); + }; + try { recording::finalize_once(state, stop, publish); assert(false); } + catch (const std::runtime_error&) {} + assert(state.finalized && state.pending() && stops == 1); + recording::finalize_once(state, stop, publish); + assert(!state.pending() && stops == 1 && attempts == 2); + recording::finalize_once(state, stop, publish); + assert(stops == 1 && attempts == 2); +} From ed2b8e635b671b78173baee408a6b5998bd58365 Mon Sep 17 00:00:00 2001 From: fraa2a Date: Fri, 9 Oct 2026 16:54:05 +0200 Subject: [PATCH 06/14] Guard timeline edits and preserve fast thumbnail retries --- app/desktop-ui/tests/audit.mjs | 32 +++++++++++++++++++++++- app/desktop-ui/ui/src/home/clip-card.tsx | 4 +-- app/desktop-ui/ui/src/lib/api.ts | 8 +++--- 3 files changed, 37 insertions(+), 7 deletions(-) diff --git a/app/desktop-ui/tests/audit.mjs b/app/desktop-ui/tests/audit.mjs index 69032c3..b817807 100644 --- a/app/desktop-ui/tests/audit.mjs +++ b/app/desktop-ui/tests/audit.mjs @@ -36,6 +36,7 @@ try { const clips = Array.from({ length: 15 }, (_, i) => ({ id: i + 1, source: "replay", catalog_uid: "catalog-replay", clip_uid: `clip${i + 1}`, media_revision: 0, video_file: `video${i + 1}.mkv`, title: `Match ${String(i + 1).padStart(2, "0")}`, thumbnail_file: `thumb${i + 1}.svg`, video_path: `video${i + 1}.mkv`, thumbnail_path: `thumb${i + 1}.svg`, created_at_utc: "2026-10-08T10:00:00Z", duration_seconds: 30, game_process_name: "arena.exe", game_display_name: "Arena", favorite: false, hashtags: ["gameplay"], size_bytes: 12000000 })); const collections = [{ id: 1, name: "Best moments", color: "#c4ff42", clip_count: 3, created_at_utc: "2026-10-08T10:00:00Z" }]; let engine = { connected: true, recording: false, replay_enabled: true, capture_running: true, replay_running: true, recording_error: "", version: "1.6.2" }; + const bookmarks = []; const calls = []; window.__uiTest = { calls, config, engine, clips, collections, failCommand: false, unknown: [] }; window.__uiTest.maximized=false; window.__uiTest.mediaLoads=0; window.__uiTest.saveDelay=0; window.__uiTest.activeSaves=0; window.__uiTest.maxSaves=0; @@ -75,7 +76,19 @@ try { case "game_icon": case "exe_icon": return null; case "game_artwork": return { icon: null, cover: null }; - case "clip_list_bookmarks": return []; + case "clip_list_bookmarks": return structuredClone(bookmarks); + case "clip_add_bookmark": + case "clip_update_bookmark": + case "clip_delete_bookmark": + case "clip_trim": { + const clip = clips.find((clip) => clip.id === args.id && clip.source === args.source); + if (args.mediaRevision !== clip.media_revision) throw new Error("Stale media revision"); + if (command === "clip_add_bookmark") bookmarks.push({seq:1,time_seconds:args.timeSeconds,label:args.label,color:args.color}); + if (command === "clip_update_bookmark") Object.assign(bookmarks.find((bm)=>bm.seq===args.seq), {label:args.label,color:args.color}); + if (command === "clip_delete_bookmark") bookmarks.splice(bookmarks.findIndex((bm)=>bm.seq===args.seq),1); + if (command === "clip_trim") { clip.duration_seconds=args.end-args.start; clip.media_revision++; } + return; + } case "clip_set_favorite": clips.find((clip) => clip.id === args.id).favorite = args.favorite; return; case "list_collections": return structuredClone(collections); case "collection_clips": return structuredClone(clips.slice(0, 3)); @@ -223,13 +236,30 @@ try { assert.equal(await page.evaluate(()=>window.__uiTest.calls.filter(c=>c.command==='collection_clips').length),0); assert.equal(await page.evaluate(()=>window.__uiTest.calls.filter(c=>c.command==='collection_memberships').length),1); }); + await check('S03 timeline mutations use the clip media revision',async()=>{ + await page.evaluate(()=>{window.__uiTest.clips[0].media_revision=7;window.__uiTest.emit();}); + await page.getByRole('button',{name:'Open Match 01',exact:true}).click(); + await page.evaluate(()=>{Object.defineProperty(HTMLMediaElement.prototype,'duration',{get:()=>30});document.querySelector('.detail video').dispatchEvent(new Event('loadedmetadata'));}); + await page.getByTitle('Add bookmark at current time',{exact:true}).click(); + await until(async()=>await page.getByTitle('Edit bookmark',{exact:true}).count()===1,'bookmark added'); + await page.getByTitle('Edit bookmark',{exact:true}).click();await page.locator('.bm-label-input').fill('Edited');await page.keyboard.press('Enter'); + await until(async()=>await page.locator('.bm-label').textContent()==='Edited','bookmark updated'); + await page.getByTitle('Delete bookmark',{exact:true}).click();await until(async()=>await page.getByTitle('Edit bookmark',{exact:true}).count()===0,'bookmark deleted'); + await page.getByTitle('Trim',{exact:true}).click();await page.locator('.trim-start').focus();await page.keyboard.press('ArrowRight');await page.getByRole('button',{name:'Apply',exact:true}).click(); + await until(async()=>await page.evaluate(()=>window.__uiTest.clips[0].media_revision)===8,'clip trimmed'); + }); await check('Q02 transient media saturation retries thumbnail without regeneration',async()=>{ + await page.evaluate(() => { + window.__retryFrame = window.requestAnimationFrame; + window.requestAnimationFrame = (callback) => setTimeout(() => callback(performance.now()), 250); + }); let requests=0; await page.route('**/flaky.svg*',route=>{requests++;return requests===1?route.fulfill({status:503}):route.fulfill({contentType:'image/svg+xml',body:''});}); await page.evaluate(()=>{window.__uiTest.clips[0].thumbnail_path='flaky.svg';window.__uiTest.emit();}); await until(async()=>requests>=2&&await page.locator('.card').first().locator('.card-thumb').evaluate(img=>img.complete&&img.naturalWidth>0),'thumbnail retry'); assert.equal(await page.evaluate(()=>window.__uiTest.calls.filter(c=>c.command==='clip_regen_thumb').length),0); await page.unroute('**/flaky.svg*'); + await page.evaluate(() => { window.requestAnimationFrame = window.__retryFrame; }); }); await check('F06 engine fallback restores missing thumbnail path',async()=>{ await page.evaluate(()=>{const c=window.__uiTest.clips[0];c.thumbnail_file=null;c.thumbnail_path=null;c.video_file='unsupported-video.mkv';window.__uiTest.emit();}); diff --git a/app/desktop-ui/ui/src/home/clip-card.tsx b/app/desktop-ui/ui/src/home/clip-card.tsx index 0f21617..bcfb3b5 100644 --- a/app/desktop-ui/ui/src/home/clip-card.tsx +++ b/app/desktop-ui/ui/src/home/clip-card.tsx @@ -1,5 +1,5 @@ import { memo } from "preact/compat"; -import { useEffect, useRef, useState } from "preact/hooks"; +import { useEffect, useLayoutEffect, useRef, useState } from "preact/hooks"; import { type Clip, clipApi, clipKey, exeIconUrl, mediaUrl, thumbUrl } from "../lib/api.ts"; import { enqueueMediaProbe } from "../lib/media-probes.ts"; import { appLabel, formatDate, formatDuration, formatSize } from "../lib/format.ts"; @@ -60,7 +60,7 @@ export const ClipCard = memo(function ClipCard( const multitrack = useMultiTrackAudio(preview ? videoEl : null, preview ? mediaUrl(clip) : null); - useEffect(() => { + useLayoutEffect(() => { clearTimeout(thumbRetryTimer.current); thumbAttempts.current = 0; setDisplayDuration(clip.duration_seconds); diff --git a/app/desktop-ui/ui/src/lib/api.ts b/app/desktop-ui/ui/src/lib/api.ts index 9e9c897..b4790f6 100644 --- a/app/desktop-ui/ui/src/lib/api.ts +++ b/app/desktop-ui/ui/src/lib/api.ts @@ -129,15 +129,15 @@ export const clipApi = { }, revealInExplorer: (c: Clip) => ok(invoke("reveal_in_explorer", { path: c.video_path })), trim: (c: Clip, start: number, end: number) => - ok(invoke("clip_trim", { ...clipIdentity(c), start, end })), + ok(invoke("clip_trim", { ...clipIdentity(c), mediaRevision: c.media_revision ?? 0, start, end })), listBookmarks: (c: Clip) => invoke("clip_list_bookmarks", { ...clipIdentity(c) }), addBookmark: (c: Clip, timeSeconds: number, label: string, color: string) => - ok(invoke("clip_add_bookmark", { ...clipIdentity(c), timeSeconds, label, color })), + ok(invoke("clip_add_bookmark", { ...clipIdentity(c), mediaRevision: c.media_revision ?? 0, timeSeconds, label, color })), updateBookmark: (c: Clip, seq: number, label: string, color: string) => - ok(invoke("clip_update_bookmark", { ...clipIdentity(c), seq, label, color })), + ok(invoke("clip_update_bookmark", { ...clipIdentity(c), mediaRevision: c.media_revision ?? 0, seq, label, color })), deleteBookmark: (c: Clip, seq: number) => - ok(invoke("clip_delete_bookmark", { ...clipIdentity(c), seq })), + ok(invoke("clip_delete_bookmark", { ...clipIdentity(c), mediaRevision: c.media_revision ?? 0, seq })), recordingAddBookmark: () => ok(invoke("recording_add_bookmark")), }; From b72ad3c6447576b30b3a5e30aa1a8976d99051d9 Mon Sep 17 00:00:00 2001 From: fraa2a Date: Fri, 9 Oct 2026 16:54:14 +0200 Subject: [PATCH 07/14] fix(ui-host): restore reader snapshots and timeline revision guards --- app/desktop-ui/src-tauri/Cargo.lock | 7 -- app/desktop-ui/src-tauri/Cargo.toml | 2 +- app/desktop-ui/src-tauri/src/clip_catalog.rs | 33 ++++---- .../src-tauri/src/clip_mutations.rs | 39 +++++++++ app/desktop-ui/src-tauri/src/commands.rs | 82 +++---------------- tests/rust/src/host_tests.rs | 37 +++++++++ 6 files changed, 108 insertions(+), 92 deletions(-) diff --git a/app/desktop-ui/src-tauri/Cargo.lock b/app/desktop-ui/src-tauri/Cargo.lock index 0158998..f0c2c0e 100644 --- a/app/desktop-ui/src-tauri/Cargo.lock +++ b/app/desktop-ui/src-tauri/Cargo.lock @@ -1573,12 +1573,6 @@ dependencies = [ "pin-project-lite", ] -[[package]] -name = "http-range" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "21dec9db110f5f872ed9699c3ecf50cf16f423502706ba5c72462e28d3157573" - [[package]] name = "httparse" version = "1.10.1" @@ -3530,7 +3524,6 @@ dependencies = [ "gtk", "heck 0.5.0", "http", - "http-range", "jni", "libc", "log", diff --git a/app/desktop-ui/src-tauri/Cargo.toml b/app/desktop-ui/src-tauri/Cargo.toml index 7fc5c7d..7f86726 100644 --- a/app/desktop-ui/src-tauri/Cargo.toml +++ b/app/desktop-ui/src-tauri/Cargo.toml @@ -7,7 +7,7 @@ edition = "2021" tauri-build = { version = "2", features = [] } [dependencies] -tauri = { version = "2", features = ["protocol-asset"] } +tauri = { version = "2", features = [] } rusqlite = { version = "0.32", features = ["bundled"] } serde = { version = "1", features = ["derive"] } serde_json = "1" diff --git a/app/desktop-ui/src-tauri/src/clip_catalog.rs b/app/desktop-ui/src-tauri/src/clip_catalog.rs index 59a0509..0221563 100644 --- a/app/desktop-ui/src-tauri/src/clip_catalog.rs +++ b/app/desktop-ui/src-tauri/src/clip_catalog.rs @@ -60,12 +60,8 @@ pub struct Clip { pub thumbnail_path: Option, } -fn db_path(source: ClipSource) -> PathBuf { - let dirs = settings_store::output_dirs(); - match source { - ClipSource::Replay => dirs.clips.join("clips.db"), - ClipSource::Manual => dirs.recs.join("recs.db"), - } +fn catalog_path(source: ClipSource, folder: &Path) -> PathBuf { + folder.join(match source { ClipSource::Replay=>"clips.db",ClipSource::Manual=>"recs.db" }) } fn media_folder(source: ClipSource) -> PathBuf { @@ -78,7 +74,7 @@ fn media_folder(source: ClipSource) -> PathBuf { fn open(source: ClipSource) -> Option { let conn = - Connection::open_with_flags(db_path(source), OpenFlags::SQLITE_OPEN_READ_ONLY).ok()?; + Connection::open_with_flags(catalog_path(source,&media_folder(source)),OpenFlags::SQLITE_OPEN_READ_ONLY).ok()?; conn.busy_timeout(std::time::Duration::from_millis(4000)) .ok()?; Some(conn) @@ -230,11 +226,15 @@ fn map_clip_row( }) } -fn read_source(source: ClipSource, filter: &ClipFilter) -> Vec { - let Some(conn) = open(source) else { +fn read_source(source: ClipSource,filter: &ClipFilter) -> Vec { + read_source_in(source,filter,&media_folder(source)) +} + +pub(crate) fn read_source_in(source: ClipSource,filter: &ClipFilter,folder: &Path) -> Vec { + let Ok(conn)=Connection::open_with_flags(catalog_path(source,folder),OpenFlags::SQLITE_OPEN_READ_ONLY) else { return Vec::new(); }; - let folder = media_folder(source); + let _=conn.busy_timeout(std::time::Duration::from_millis(4000)); let tags = clip_hashtags(&conn); let artwork = game_catalog::ArtworkCache::load(); // ISO-8601 strings sort lexicographically; list_clips re-sorts the merged @@ -246,7 +246,7 @@ fn read_source(source: ClipSource, filter: &ClipFilter) -> Vec { }; let Ok(rows) = stmt.query_map([], |row| { - map_clip_row(row, source, &folder, &tags, &artwork) + map_clip_row(row,source,folder,&tags,&artwork) }) else { return Vec::new(); }; @@ -256,15 +256,18 @@ fn read_source(source: ClipSource, filter: &ClipFilter) -> Vec { .collect() } -pub fn clips_by_ids(source: ClipSource, ids: &[i64]) -> Result, String> { - let path = db_path(source); +pub fn clips_by_ids(source: ClipSource,ids: &[i64]) -> Result,String> { + clips_by_ids_in(source,ids,&media_folder(source)) +} + +pub(crate) fn clips_by_ids_in(source: ClipSource,ids: &[i64],folder: &Path) -> Result,String> { + let path=catalog_path(source,folder); path.metadata() .map_err(|err| format!("catalog unavailable: {err}"))?; let conn = Connection::open_with_flags(path, OpenFlags::SQLITE_OPEN_READ_ONLY) .map_err(|err| err.to_string())?; conn.busy_timeout(std::time::Duration::from_millis(4000)) .map_err(|err| err.to_string())?; - let folder = media_folder(source); let tags = clip_hashtags(&conn); let artwork = game_catalog::ArtworkCache::load(); let sql = format!("{} WHERE id = ?1", clip_select_sql(&conn)); @@ -273,7 +276,7 @@ pub fn clips_by_ids(source: ClipSource, ids: &[i64]) -> Result Result<(), String> { } } +pub fn timeline(method: &str,source: &str,id: i64,catalog_uid: &str,clip_uid: &str,media_revision: i64,mut fields: Value) -> Result<(),String> { + fields["source"]=serde_json::json!(source); + fields["id"]=serde_json::json!(id); + fields["catalog_uid"]=serde_json::json!(catalog_uid); + fields["clip_uid"]=serde_json::json!(clip_uid); + fields["media_revision"]=serde_json::json!(media_revision); + send(method,fields) +} + fn stage(root: &Path, data_url: &str) -> Result<(String, PathBuf), String> { if data_url.len() > 12 * 1024 * 1024 { return Err("thumbnail too large".into()); @@ -101,6 +110,36 @@ pub fn capture( #[cfg(test)] mod tests { use super::*; + #[test] + fn timeline_requests_send_identity_revision_and_edit_fields_over_rpc() { + use std::{io::{BufRead,BufReader,Write},net::TcpListener}; + let listener=TcpListener::bind((std::net::Ipv4Addr::LOCALHOST,45991)).unwrap(); + let server=std::thread::spawn(move || { + let mut received=Vec::new(); + for _ in 0..4 { + let (mut stream,_)=listener.accept().unwrap(); + stream.set_read_timeout(Some(std::time::Duration::from_secs(4))).unwrap(); + let mut line=String::new();BufReader::new(stream.try_clone().unwrap()).read_line(&mut line).unwrap(); + let request: Value=serde_json::from_str(&line).unwrap(); + writeln!(stream,"{}",serde_json::json!({"jsonrpc":"2.0","id":request["id"],"result":null})).unwrap();received.push(request); + } + received + }); + let edits=[ + ("clip_trim",serde_json::json!({"start":2.0,"end":4.0})), + ("clip_add_bookmark",serde_json::json!({"time_seconds":3.0,"label":"Marker","color":"red"})), + ("clip_update_bookmark",serde_json::json!({"seq":2,"label":"New label","color":"blue"})), + ("clip_delete_bookmark",serde_json::json!({"seq":2})), + ]; + for (method,fields) in &edits {timeline(method,"manual",9,"catalog-one","clip-one",11,fields.clone()).unwrap();} + for (request,(method,fields)) in server.join().unwrap().iter().zip(edits) { + assert_eq!(request["method"],method);let params=&request["params"]; + assert_eq!(params["source"],"manual");assert_eq!(params["id"],9); + assert_eq!(params["catalog_uid"],"catalog-one");assert_eq!(params["clip_uid"],"clip-one");assert_eq!(params["media_revision"],11); + for (key,value) in fields.as_object().unwrap() {assert_eq!(¶ms[key],value);} + } + } + #[test] fn staging_bounds_validates_and_creates_unique_uploads() { let root = std::env::temp_dir().join(format!("monolith-upload-{}", std::process::id())); diff --git a/app/desktop-ui/src-tauri/src/commands.rs b/app/desktop-ui/src-tauri/src/commands.rs index 64c3245..ced334a 100644 --- a/app/desktop-ui/src-tauri/src/commands.rs +++ b/app/desktop-ui/src-tauri/src/commands.rs @@ -319,23 +319,9 @@ pub async fn clip_regen_thumb( .await } #[tauri::command] -pub async fn clip_trim( - source: String, - id: i64, - catalog_uid: String, - clip_uid: String, - start: f64, - end: f64, -) -> Result<(), String> { - clip_mutation( - "clip_trim", - source, - id, - catalog_uid, - clip_uid, - serde_json::json!({"start":start,"end":end}), - ) - .await +pub async fn clip_trim(source: String,id: i64,catalog_uid: String,clip_uid: String,media_revision: i64,start: f64,end: f64) -> Result<(),String> { + let src=parse_source(&source)?; + blocking_result(move || crate::clip_mutations::timeline("clip_trim",src.as_str(),id,&catalog_uid,&clip_uid,media_revision,serde_json::json!({"start":start,"end":end}))).await } // Adds a bookmark at the current position of the running manual recording. @@ -366,63 +352,21 @@ pub async fn clip_list_bookmarks( } #[tauri::command] -pub async fn clip_add_bookmark( - source: String, - id: i64, - catalog_uid: String, - clip_uid: String, - time_seconds: f64, - label: String, - color: String, -) -> Result<(), String> { - clip_mutation( - "clip_add_bookmark", - source, - id, - catalog_uid, - clip_uid, - serde_json::json!({"time_seconds":time_seconds,"label":label,"color":color}), - ) - .await +pub async fn clip_add_bookmark(source: String,id: i64,catalog_uid: String,clip_uid: String,media_revision: i64,time_seconds: f64,label: String,color: String) -> Result<(),String> { + let src=parse_source(&source)?; + blocking_result(move || crate::clip_mutations::timeline("clip_add_bookmark",src.as_str(),id,&catalog_uid,&clip_uid,media_revision,serde_json::json!({"time_seconds":time_seconds,"label":label,"color":color}))).await } #[tauri::command] -pub async fn clip_update_bookmark( - source: String, - id: i64, - catalog_uid: String, - clip_uid: String, - seq: i64, - label: String, - color: String, -) -> Result<(), String> { - clip_mutation( - "clip_update_bookmark", - source, - id, - catalog_uid, - clip_uid, - serde_json::json!({"seq":seq,"label":label,"color":color}), - ) - .await +pub async fn clip_update_bookmark(source: String,id: i64,catalog_uid: String,clip_uid: String,media_revision: i64,seq: i64,label: String,color: String) -> Result<(),String> { + let src=parse_source(&source)?; + blocking_result(move || crate::clip_mutations::timeline("clip_update_bookmark",src.as_str(),id,&catalog_uid,&clip_uid,media_revision,serde_json::json!({"seq":seq,"label":label,"color":color}))).await } #[tauri::command] -pub async fn clip_delete_bookmark( - source: String, - id: i64, - catalog_uid: String, - clip_uid: String, - seq: i64, -) -> Result<(), String> { - clip_mutation( - "clip_delete_bookmark", - source, - id, - catalog_uid, - clip_uid, - serde_json::json!({"seq":seq}), - ) - .await +pub async fn clip_delete_bookmark(source: String,id: i64,catalog_uid: String,clip_uid: String,media_revision: i64,seq: i64) -> Result<(),String> { + let src=parse_source(&source)?; + blocking_result(move || crate::clip_mutations::timeline("clip_delete_bookmark",src.as_str(),id,&catalog_uid,&clip_uid,media_revision,serde_json::json!({"seq":seq}))).await } + #[tauri::command] pub async fn clip_snapshot(source: String, id: i64) -> Result { let src = parse_source(&source)?; diff --git a/tests/rust/src/host_tests.rs b/tests/rust/src/host_tests.rs index 3e522a1..eb0c025 100644 --- a/tests/rust/src/host_tests.rs +++ b/tests/rust/src/host_tests.rs @@ -101,3 +101,40 @@ fn memberships_survive_missing_media_and_reject_reused_ids_and_catalogs() { drop(db); fs::remove_dir_all(root).unwrap(); } + +fn switched_roots(name: &str) -> (std::path::PathBuf,std::path::PathBuf) { + let root=std::env::temp_dir().join(format!("monolith-root-{name}-{}",std::process::id())); + let _=fs::remove_dir_all(&root);fs::create_dir_all(&root).unwrap();std::env::set_var("LOCALAPPDATA",&root); + for (name,content) in [("a",b"aaaa".as_slice()),("b",b"bbbbbbbbb".as_slice())] { + let folder=root.join(name);fs::create_dir_all(folder.join(".thumbs")).unwrap(); + fs::write(folder.join("a.mp4"),content).unwrap();fs::write(folder.join(".thumbs/a.png"),content).unwrap(); + let db=Connection::open(folder.join("clips.db")).unwrap(); + db.execute_batch("CREATE TABLE catalog_metadata(key TEXT PRIMARY KEY,value TEXT NOT NULL); + CREATE TABLE clips(id INTEGER PRIMARY KEY,video_file TEXT,thumbnail_file TEXT,created_at_utc TEXT,duration_seconds REAL,game_process_name TEXT,game_display_name TEXT,favorite INTEGER,title TEXT,clip_uid TEXT NOT NULL); + CREATE TABLE clip_hashtags(clip_id INTEGER,tag TEXT); + INSERT INTO clips VALUES(1,'a.mp4','a.png','2026-10-08T00:00:00Z',5,NULL,NULL,0,'A','clip-one');").unwrap(); + db.execute("INSERT INTO catalog_metadata VALUES('catalog_uid',?1)",[name]).unwrap(); + } + let pinned=root.join("a"); + settings_store::write_config(&json!({"output":{"clips_directory":pinned,"recordings_directory":root.join("recs")}})).unwrap(); + settings_store::write_config(&json!({"output":{"clips_directory":root.join("b"),"recordings_directory":root.join("recs")}})).unwrap(); + (root,pinned) +} +fn assert_pinned(clip: &clip_catalog::Clip,folder: &std::path::Path) { + assert_eq!(clip.catalog_uid,"a");assert_eq!(clip.video_path,folder.join("a.mp4").to_string_lossy()); + assert_eq!(clip.thumbnail_path.as_deref(),Some(folder.join(".thumbs/a.png").to_string_lossy().as_ref()));assert_eq!(clip.size_bytes,4); +} +#[test] +fn listing_keeps_catalog_and_media_in_the_resolved_folder() { + let _guard=crate::CATALOG_ENV_LOCK.lock().unwrap_or_else(|err|err.into_inner()); + let (root,pinned)=switched_roots("list"); + let clips=clip_catalog::read_source_in(clip_catalog::ClipSource::Replay,&clip_catalog::ClipFilter::default(),&pinned); + assert_eq!(clips.len(),1);assert_pinned(&clips[0],&pinned);fs::remove_dir_all(root).unwrap(); +} +#[test] +fn id_reads_keep_catalog_and_media_in_the_resolved_folder() { + let _guard=crate::CATALOG_ENV_LOCK.lock().unwrap_or_else(|err|err.into_inner()); + let (root,pinned)=switched_roots("ids"); + let clips=clip_catalog::clips_by_ids_in(clip_catalog::ClipSource::Replay,&[1],&pinned).unwrap(); + assert_pinned(&clips[&1],&pinned);fs::remove_dir_all(root).unwrap(); +} From 249e0204ed7f4f9de3f9106e9237d1046b47a0b3 Mon Sep 17 00:00:00 2001 From: fraa2a Date: Fri, 9 Oct 2026 16:54:16 +0200 Subject: [PATCH 08/14] fix: resolve engine process path aliases before matching --- app/updater/src-tauri/src/process.rs | 77 +++++++++++++++++++++++----- 1 file changed, 63 insertions(+), 14 deletions(-) diff --git a/app/updater/src-tauri/src/process.rs b/app/updater/src-tauri/src/process.rs index 938f81f..a90b1e9 100644 --- a/app/updater/src-tauri/src/process.rs +++ b/app/updater/src-tauri/src/process.rs @@ -1,4 +1,3 @@ -#[cfg(windows)] use std::path::Path; use std::process::Child; use std::time::{Duration, Instant}; @@ -29,9 +28,54 @@ pub fn wait_ready( } } +fn image_path(path: &Path) -> Result { + let parent = std::fs::canonicalize(path.parent().ok_or("engine path has no parent")?) + .map_err(|e| format!("engine directory: {e}"))?; + let path = parent.join(path.file_name().ok_or("engine path has no filename")?); + Ok(path + .to_string_lossy() + .trim_start_matches("\\\\?\\") + .to_lowercase()) +} + #[cfg(test)] mod tests { use super::*; + #[cfg(not(windows))] + #[test] + fn image_identity_resolves_parent_aliases_when_executable_is_missing() { + let root = std::env::temp_dir().join(format!("monolith-image-path-{}", std::process::id())); + std::fs::create_dir_all(root.join("installation")).unwrap(); + std::os::unix::fs::symlink(root.join("installation"), root.join("alias")).unwrap(); + let expected = image_path(&root.join("installation/Monolith.exe")).unwrap(); + let actual = image_path(&root.join("alias/Monolith.exe")).unwrap(); + std::fs::remove_dir_all(root).unwrap(); + assert_eq!(actual, expected); + } + #[cfg(windows)] + #[test] + fn image_identity_expands_short_directory_names_when_executable_is_missing() { + use std::os::windows::ffi::OsStrExt; + use windows::core::PCWSTR; + use windows::Win32::Storage::FileSystem::GetShortPathNameW; + let root = + std::env::temp_dir().join(format!("monolith image directory {}", std::process::id())); + std::fs::create_dir_all(&root).unwrap(); + let wide: Vec = root + .as_os_str() + .encode_wide() + .chain(std::iter::once(0)) + .collect(); + let mut short = vec![0u16; 32768]; + let length = unsafe { GetShortPathNameW(PCWSTR(wide.as_ptr()), Some(&mut short)) } as usize; + assert!(length > 0 && length < short.len()); + let alias = std::path::PathBuf::from(String::from_utf16_lossy(&short[..length])); + let expected = + image_path(&std::fs::canonicalize(&root).unwrap().join("Monolith.exe")).unwrap(); + let actual = image_path(&alias.join("Monolith.exe")).unwrap(); + std::fs::remove_dir_all(root).unwrap(); + assert_eq!(actual, expected); + } #[test] #[ignore] fn short_lived_child() { @@ -72,7 +116,7 @@ mod tests { .env("MONOLITH_PROCESS_TEST", &root) .spawn() .unwrap(); - let result = std::panic::catch_unwind(|| { + let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { for _ in 0..500 { if root.join("ready").exists() { break; @@ -80,12 +124,21 @@ mod tests { std::thread::sleep(Duration::from_millis(10)); } assert!(root.join("ready").exists()); + assert!( + child.try_wait().unwrap().is_none(), + "fixture exited before discovery" + ); let processes = EngineProcesses::capture(&exe).unwrap(); - assert!(processes.running()); + assert!( + processes.running(), + "live child {} at {:?} was not discovered", + child.id(), + exe + ); std::fs::write(root.join("exit"), b"exit").unwrap(); assert!(processes.wait_exit(Duration::from_millis(50)).is_err()); processes.wait_exit(Duration::from_secs(5)).unwrap(); - }); + })); let _ = child.kill(); let _ = child.wait(); std::fs::remove_dir_all(root).unwrap(); @@ -135,13 +188,7 @@ impl EngineProcesses { OpenProcess, QueryFullProcessImageNameW, PROCESS_ACCESS_RIGHTS, PROCESS_NAME_WIN32, PROCESS_QUERY_LIMITED_INFORMATION, }; - let expected = std::fs::canonicalize(exe.parent().ok_or("engine path has no parent")?) - .map_err(|e| format!("engine directory: {e}"))? - .join(exe.file_name().ok_or("engine path has no filename")?); - let expected = expected - .to_string_lossy() - .trim_start_matches("\\\\?\\") - .to_lowercase(); + let expected = image_path(exe)?; let mut processes = Self(Vec::new()); unsafe { let snapshot = @@ -185,9 +232,11 @@ impl EngineProcesses { let _ = CloseHandle(handle); return Err(format!("engine process path: {e}")); } - let actual = String::from_utf16_lossy(&path[..size as usize]) - .trim_start_matches("\\\\?\\") - .to_lowercase(); + let actual = String::from_utf16_lossy(&path[..size as usize]); + let actual = image_path(Path::new(&actual)).map_err(|error| { + let _ = CloseHandle(handle); + error + })?; if actual == expected { processes.0.push(handle); } else { From 561b550be7ababfaf9b408b8a7d47ad770a4d341 Mon Sep 17 00:00:00 2001 From: fraa2a Date: Fri, 9 Oct 2026 16:54:25 +0200 Subject: [PATCH 09/14] fix(storage): recover trims and guard catalog media mutations --- libs/recording/bookmark_journal.h | 75 +++++ libs/storage/CMakeLists.txt | 2 + libs/storage/storage.cpp | 509 ++++++++++++++++++++++++++--- libs/storage/storage.h | 8 + tests/u6/CMakeLists.txt | 3 +- tests/u6/storage_mutation_test.cpp | 108 ++++-- 6 files changed, 646 insertions(+), 59 deletions(-) create mode 100644 libs/recording/bookmark_journal.h diff --git a/libs/recording/bookmark_journal.h b/libs/recording/bookmark_journal.h new file mode 100644 index 0000000..5fee416 --- /dev/null +++ b/libs/recording/bookmark_journal.h @@ -0,0 +1,75 @@ +#pragma once +#include +#include +#include +#include +#include +#include +#ifdef _WIN32 +#include +#endif +namespace recording { +struct Bookmark { + double time_seconds = 0; + std::string label; + std::string color; +}; +inline std::filesystem::path bookmark_journal_path(const std::wstring& media) { + return std::filesystem::path(media + L".bookmarks.json"); +} +inline bool write_bookmark_journal(const std::wstring& media, + const std::vector& bookmarks, std::string* error = nullptr) { + try { + if (bookmarks.size() > 4096) throw std::runtime_error("Too many bookmarks"); + nlohmann::json rows = nlohmann::json::array(); + for (const auto& b : bookmarks) { + if (!std::isfinite(b.time_seconds) || b.time_seconds < 0) + throw std::runtime_error("Invalid bookmark time"); + rows.push_back({{"time_seconds", b.time_seconds}, {"label", b.label}, {"color", b.color}}); + } + const auto text = nlohmann::json{{"version", 1}, {"bookmarks", rows}}.dump(); + if (text.size() > 1024 * 1024) throw std::runtime_error("Bookmark journal too large"); + const auto path = bookmark_journal_path(media); + const auto temp = std::filesystem::path(media + L".bookmarks.pending.tmp"); + if (std::filesystem::is_symlink(std::filesystem::symlink_status(path)) || + std::filesystem::is_symlink(std::filesystem::symlink_status(temp))) + throw std::runtime_error("Bookmark journal symlink rejected"); + { + std::ofstream out(temp, std::ios::binary | std::ios::trunc); + out.write(text.data(), static_cast(text.size())); + out.flush(); + if (!out) throw std::runtime_error("Bookmark journal write failed"); + } +#ifdef _WIN32 + if (!MoveFileExW(temp.c_str(), path.c_str(), MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH)) + throw std::runtime_error("Bookmark journal replace failed"); +#else + std::filesystem::rename(temp, path); +#endif + return true; + } catch (const std::exception& e) { if (error) *error = e.what(); return false; } +} +inline bool read_bookmark_journal(const std::wstring& media, + std::vector& bookmarks, std::string* error = nullptr) { + try { + const auto path = bookmark_journal_path(media); + if (std::filesystem::is_symlink(std::filesystem::symlink_status(path)) || + !std::filesystem::is_regular_file(path) || std::filesystem::file_size(path) > 1024 * 1024) + throw std::runtime_error("Invalid bookmark journal file"); + std::ifstream in(path, std::ios::binary); + const auto json = nlohmann::json::parse(in); + if (json.at("version") != 1 || !json.at("bookmarks").is_array() || + json.at("bookmarks").size() > 4096) throw std::runtime_error("Invalid bookmark journal schema"); + std::vector rows; + for (const auto& item : json.at("bookmarks")) { + Bookmark b{item.at("time_seconds").get(), item.at("label").get(), + item.at("color").get()}; + if (!std::isfinite(b.time_seconds) || b.time_seconds < 0) + throw std::runtime_error("Invalid bookmark time"); + rows.push_back(std::move(b)); + } + bookmarks = std::move(rows); + return true; + } catch (const std::exception& e) { if (error) *error = e.what(); return false; } +} +} diff --git a/libs/storage/CMakeLists.txt b/libs/storage/CMakeLists.txt index 513820c..3efb471 100644 --- a/libs/storage/CMakeLists.txt +++ b/libs/storage/CMakeLists.txt @@ -17,10 +17,12 @@ target_compile_definitions(storage # SQLite from vcpkg (target name is unofficial::sqlite3::sqlite3). find_package(unofficial-sqlite3 CONFIG REQUIRED) +find_package(nlohmann_json CONFIG REQUIRED) target_link_libraries(storage PRIVATE encoding + nlohmann_json::nlohmann_json platform_win unofficial::sqlite3::sqlite3 ) diff --git a/libs/storage/storage.cpp b/libs/storage/storage.cpp index 3992808..ec6a811 100644 --- a/libs/storage/storage.cpp +++ b/libs/storage/storage.cpp @@ -1,6 +1,9 @@ #include "storage.h" #include +#include +#include +#include #include #include @@ -15,9 +18,13 @@ #include #include +#include +#include #include #include +#include #include +#include #include #include #include @@ -285,6 +292,60 @@ std::mutex g_mutation_map_guard; std::unordered_map> g_mutation_map; +std::wstring joined(const std::wstring &folder, const std::wstring &name) { + return (fs::path(folder) / name).wstring(); +} +bool media_busy(const std::wstring &folder, const std::wstring &video, std::string *error) { + if (!encoding::media_is_owned(joined(folder, video))) return false; + if (error) *error = "clip is busy publishing"; + return true; +} +bool media_path_valid(const std::wstring &folder, const std::wstring &path, std::string *error) { + std::error_code ec; + const auto status = fs::symlink_status(path, ec); + if (ec || !fs::is_regular_file(status)) { + if (error) *error = "media is not an accessible regular file"; + return false; + } +#ifdef _WIN32 + const DWORD attributes = GetFileAttributesW(path.c_str()); + if (attributes == INVALID_FILE_ATTRIBUTES || (attributes & FILE_ATTRIBUTE_REPARSE_POINT)) { + if (error) *error = "media reparse points are not allowed"; + return false; + } +#endif + const auto root = fs::canonical(folder, ec); + if (ec) { if (error) *error = ec.message(); return false; } + const auto target = fs::canonical(path, ec); + if (ec || target.parent_path() != root) { + if (error) *error = "media resolves outside the catalog root"; + return false; + } + return true; +} +bool directory_valid(const std::wstring &parent, const std::wstring &path, std::string *error) { + std::error_code ec; + const auto status = fs::symlink_status(path, ec); + if (ec || !fs::is_directory(status) || fs::is_symlink(status)) { + if (error) *error = "invalid media subdirectory"; + return false; + } +#ifdef _WIN32 + const DWORD attributes = GetFileAttributesW(path.c_str()); + if (attributes == INVALID_FILE_ATTRIBUTES || (attributes & FILE_ATTRIBUTE_REPARSE_POINT)) { + if (error) *error = "media subdirectory reparse points are not allowed"; + return false; + } +#endif + const auto root = fs::canonical(parent, ec); + if (ec) { if (error) *error = ec.message(); return false; } + const auto target = fs::canonical(path, ec); + if (ec || target.parent_path() != root) { + if (error) *error = "media subdirectory resolves outside its parent"; + return false; + } + return true; +} bool leaf(const std::wstring &s) { return !s.empty() && s != L"." && s != L".." && s.back() != L'.' && s.back() != L' ' && @@ -301,11 +362,11 @@ bool token_ok(const std::string &s) { }); } std::wstring quarantine_dir(const std::wstring &folder) { - return folder + L"\\.monolith-mutations"; + return joined(folder, L".monolith-mutations"); } bool no_replace_move(const std::wstring &from, const std::wstring &to) { #ifdef _WIN32 - return MoveFileW(from.c_str(), to.c_str()) != FALSE; + return MoveFileExW(from.c_str(), to.c_str(), MOVEFILE_WRITE_THROUGH) != FALSE; #else std::error_code ec; if (fs::exists(to, ec) || ec) @@ -316,7 +377,8 @@ bool no_replace_move(const std::wstring &from, const std::wstring &to) { } bool path_exists(const std::wstring &p) { std::error_code ec; - return fs::exists(p, ec) && !ec; + // Inaccessible paths must never be treated as absent by mutations. + return fs::exists(p, ec) || bool(ec); } std::string new_token() { std::random_device rd; @@ -331,6 +393,9 @@ class MutationLock { std::error_code ec; auto canonical = fs::weakly_canonical(db_path, ec); key_ = ec ? db_path : canonical.wstring(); +#ifdef _WIN32 + std::transform(key_.begin(), key_.end(), key_.begin(), ::towlower); +#endif { std::lock_guard guard(g_mutation_map_guard); auto &weak = g_mutation_map[key_]; @@ -448,7 +513,7 @@ bool journal_clear(sqlite3 *db, const std::string &token, std::string *error) { return ok; } bool valid_mutation(const Mutation &m) { - return token_ok(m.token) && (m.op == "delete" || m.op == "rename") && + return token_ok(m.token) && (m.op == "delete" || m.op == "rename" || m.op == "trim") && (m.stage == "prepared" || m.stage == "committed") && leaf(m.old_v) && optional_leaf(m.old_t) && optional_leaf(m.new_v) && optional_leaf(m.new_t); @@ -486,12 +551,12 @@ struct ClipDb::Impl { sqlite3_close_v2(db); } - std::wstring thumbs_dir() const { return folder + L"\\.thumbs"; } + std::wstring thumbs_dir() const { return joined(folder, L".thumbs"); } std::wstring video_path(const std::wstring &basename) const { - return folder + L"\\" + basename; + return joined(folder, basename); } std::wstring thumb_path(const std::wstring &basename) const { - return thumbs_dir() + L"\\" + basename; + return joined(thumbs_dir(), basename); } }; @@ -510,6 +575,20 @@ bool row_has_video(sqlite3 *db, int64_t id, const std::wstring &video) { sqlite3_finalize(st); return ok; } +bool shared_video(sqlite3 *db, int64_t id, const std::wstring &video, std::string *error) { + sqlite3_stmt *st = nullptr; + if (sqlite3_prepare_v2(db, "SELECT 1 FROM clips WHERE video_file=? AND id<>? LIMIT 1", -1, &st, nullptr) != SQLITE_OK) { + if (error) *error = sqlite3_errmsg(db); + return true; + } + const auto name = wide_to_utf8(video); + sqlite3_bind_text(st, 1, name.c_str(), -1, SQLITE_TRANSIENT); + sqlite3_bind_int64(st, 2, id); + const int result = sqlite3_step(st); + sqlite3_finalize(st); + if (result != SQLITE_DONE && error) *error = "media has duplicate catalog references"; + return result != SQLITE_DONE; +} bool recover_mutations(sqlite3 *db, const std::wstring &folder, std::string *error) { sqlite3_stmt *st = nullptr; @@ -524,7 +603,8 @@ bool recover_mutations(sqlite3 *db, const std::wstring &folder, return false; } std::vector all; - while (sqlite3_step(st) == SQLITE_ROW) { + int scan_result = SQLITE_OK; + while ((scan_result = sqlite3_step(st)) == SQLITE_ROW) { Mutation m; const auto text = [&](int n) { const auto *x = sqlite3_column_text(st, n); @@ -547,18 +627,55 @@ bool recover_mutations(sqlite3 *db, const std::wstring &folder, } all.push_back(std::move(m)); } + if (scan_result != SQLITE_DONE) { + if (error) *error = sqlite3_errmsg(db); + sqlite3_finalize(st); return false; + } sqlite3_finalize(st); for (const auto &m : all) { + if (m.op == "trim") { + const auto work = joined(quarantine_dir(folder), utf8_to_wide(m.token)); + if (!directory_valid(folder, quarantine_dir(folder), error)) return false; + const auto backup = joined(work, m.new_v), temporary = joined(work, m.new_t), original = joined(folder, m.old_v); + std::error_code ec; + const auto workspace_status = fs::symlink_status(work, ec); + if ((ec && ec != std::errc::no_such_file_or_directory) || fs::is_symlink(workspace_status)) { + if (error) *error = "cannot inspect trim workspace"; + return false; + } + if (fs::exists(work, ec) && !directory_valid(quarantine_dir(folder), work, error)) return false; + if (ec) { if (error) *error = "cannot inspect trim workspace"; return false; } + if (!row_has_video(db, m.id, m.old_v)) { if (error) *error = "trim catalog identity changed"; return false; } + const bool backup_present = fs::exists(backup, ec); + if (ec) { if (error) *error = "cannot inspect original trim backup"; return false; } + if (m.stage == "prepared" && backup_present) { + if (!media_path_valid(work, backup, error)) return false; + fs::remove(original, ec); + if (ec || !no_replace_move(backup, original)) { + if (error) *error = "cannot restore original trim media"; + return false; + } + } + if (!media_path_valid(folder, original, error)) return false; + for (const auto &file : {backup, temporary}) { + fs::remove(file, ec); + if (ec) { if (error) *error = "cannot clean trim workspace: " + ec.message(); return false; } + } + fs::remove(work, ec); + if (ec) { if (error) *error = "cannot clean trim workspace: " + ec.message(); return false; } + if (!journal_clear(db, m.token, error)) return false; + continue; + } const bool deleting = m.op == "delete"; - const std::wstring vd = deleting ? quarantine_dir(folder) + L"\\" + m.new_v - : folder + L"\\" + m.new_v; + const std::wstring vd = deleting ? joined(quarantine_dir(folder), m.new_v) + : joined(folder, m.new_v); const std::wstring td = deleting - ? (m.new_t.empty() ? L"" : quarantine_dir(folder) + L"\\" + m.new_t) - : (m.new_t.empty() ? L"" : folder + L"\\.thumbs\\" + m.new_t); - const std::wstring vs = folder + L"\\" + m.old_v; + ? (m.new_t.empty() ? L"" : joined(quarantine_dir(folder), m.new_t)) + : (m.new_t.empty() ? L"" : joined(joined(folder, L".thumbs"), m.new_t)); + const std::wstring vs = joined(folder, m.old_v); const std::wstring ts = - m.old_t.empty() ? L"" : folder + L"\\.thumbs\\" + m.old_t; + m.old_t.empty() ? L"" : joined(joined(folder, L".thumbs"), m.old_t); if (m.stage == "prepared") { if (path_exists(vs) && path_exists(vd)) { if (error) @@ -630,8 +747,13 @@ std::unique_ptr ClipDb::open(const std::wstring &folder, } const std::wstring db_name = (source == "manual") ? L"recs.db" : L"clips.db"; - const std::wstring db_path = folder + L"\\" + db_name; + const std::wstring db_path = joined(folder, db_name); + MutationLock mutation_lock(db_path); + if (!mutation_lock.ok()) { + if (error) *error = "cannot acquire catalog mutation lock"; + return nullptr; + } std::error_code ec; fs::create_directories(folder, ec); const bool existed = fs::exists(db_path, ec); @@ -650,7 +772,7 @@ std::unique_ptr ClipDb::open(const std::wstring &folder, } exec(db, "PRAGMA journal_mode=WAL;", nullptr); - exec(db, "PRAGMA synchronous=NORMAL;", nullptr); + exec(db, "PRAGMA synchronous=FULL;", nullptr); exec(db, "PRAGMA busy_timeout=4000;", nullptr); exec(db, "PRAGMA foreign_keys=ON;", nullptr); @@ -696,8 +818,23 @@ std::unique_ptr ClipDb::open(const std::wstring &folder, exec(db, "ALTER TABLE clips ADD COLUMN game_executable_path TEXT;", nullptr); - MutationLock mutation_lock(db_path); - if (!mutation_lock.ok() || !journal_schema(db, error) || + if (!has_column(db, "clips", "media_revision") && + !exec(db, "ALTER TABLE clips ADD COLUMN media_revision INTEGER NOT NULL DEFAULT 0;", error)) { + sqlite3_close(db); return nullptr; + } + if (!has_column(db, "clips", "clip_uid") && + !exec(db, "ALTER TABLE clips ADD COLUMN clip_uid TEXT NOT NULL DEFAULT '';", error)) { + sqlite3_close(db); return nullptr; + } + if (!exec(db, "BEGIN IMMEDIATE;" + "UPDATE clips SET clip_uid=lower(hex(randomblob(16))) WHERE clip_uid='';" + "CREATE UNIQUE INDEX IF NOT EXISTS idx_clip_uid ON clips(clip_uid);" + "CREATE TABLE IF NOT EXISTS catalog_metadata (key TEXT PRIMARY KEY,value TEXT NOT NULL);" + "INSERT OR IGNORE INTO catalog_metadata VALUES ('catalog_uid',lower(hex(randomblob(16))));" + "COMMIT;", error)) { + exec(db, "ROLLBACK;", nullptr); sqlite3_close(db); return nullptr; + } + if (!journal_schema(db, error) || !recover_mutations(db, folder, error)) { if (error && error->empty()) *error = "cannot acquire catalog mutation lock"; @@ -716,13 +853,34 @@ const std::wstring &ClipDb::folder() const { return impl_->folder; } std::wstring ClipDb::thumbs_dir() const { return impl_->thumbs_dir(); } int64_t ClipDb::insert_clip(const ClipRow &row, std::string *error) { + MutationLock lock(impl_->db_path); + if (!lock.ok() || !leaf(row.video_file) || !optional_leaf(row.thumbnail_file)) { + if (error) *error = "invalid catalog media path or mutation lock failure"; + return -1; + } + sqlite3_stmt *existing = nullptr; + if (sqlite3_prepare_v2(impl_->db, "SELECT id FROM clips WHERE video_file=? LIMIT 1", -1, + &existing, nullptr) != SQLITE_OK) { + if (error) *error = sqlite3_errmsg(impl_->db); + return -1; + } + const auto name = wide_to_utf8(row.video_file); + sqlite3_bind_text(existing, 1, name.c_str(), -1, SQLITE_TRANSIENT); + const int found = sqlite3_step(existing); + const int64_t prior = found == SQLITE_ROW ? sqlite3_column_int64(existing, 0) : -1; + sqlite3_finalize(existing); + if (found == SQLITE_ROW) return prior; + if (found != SQLITE_DONE) { + if (error) *error = sqlite3_errmsg(impl_->db); + return -1; + } static const char *sql = "INSERT INTO clips (video_file, thumbnail_file, title, created_at_utc, " "source, " "duration_seconds, game_process_name, game_display_name, " "game_executable_path, " - "discord_app_id, game_source, steam_app_id, confidence, favorite) " - "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)"; + "discord_app_id, game_source, steam_app_id, confidence, favorite, clip_uid) " + "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,lower(hex(randomblob(16))))"; sqlite3_stmt *st = nullptr; if (sqlite3_prepare_v2(impl_->db, sql, -1, &st, nullptr) != SQLITE_OK) { if (error) @@ -802,6 +960,8 @@ bool ClipDb::remove_clip(int64_t id, bool remove_files, std::string *error) { *error = "clip not found or has invalid catalog paths"; return false; } + if (media_busy(impl_->folder, video, error)) return false; + if (remove_files && shared_video(impl_->db, id, video, error)) remove_files = false; if (!remove_files) { if (!exec(impl_->db, "BEGIN", error) || !delete_clip_rows(impl_->db, id, error) || @@ -812,7 +972,13 @@ bool ClipDb::remove_clip(int64_t id, bool remove_files, std::string *error) { return true; } const std::wstring source_video = impl_->video_path(video); - if (!path_exists(source_video)) { // Reconcile's missing-video case: rows + std::error_code source_error; + const bool source_present = fs::exists(source_video, source_error); + if (source_error) { + if (error) *error = "cannot inspect video: " + source_error.message(); + return false; + } + if (!source_present) { // Reconcile's missing-video case: rows // only, no quarantine required. if (!exec(impl_->db, "BEGIN", error) || !delete_clip_rows(impl_->db, id, error) || @@ -822,9 +988,12 @@ bool ClipDb::remove_clip(int64_t id, bool remove_files, std::string *error) { } return true; } + if (!media_path_valid(impl_->folder, source_video, error)) return false; if (thumb.empty()) thumb = thumb_basename_for(video); const bool have_thumb = path_exists(impl_->thumb_path(thumb)); + if (have_thumb && (!directory_valid(impl_->folder, impl_->thumbs_dir(), error) || + !media_path_valid(impl_->thumbs_dir(), impl_->thumb_path(thumb), error))) return false; Mutation m{new_token(), "delete", "prepared", id, video, utf8_to_wide(new_token()), thumb, L""}; @@ -836,14 +1005,14 @@ bool ClipDb::remove_clip(int64_t id, bool remove_files, std::string *error) { m.old_t.clear(); std::error_code ec; fs::create_directories(quarantine_dir(impl_->folder), ec); - if (ec) { + if (ec || !directory_valid(impl_->folder, quarantine_dir(impl_->folder), error)) { if (error) *error = "cannot create mutation quarantine"; return false; } if (!journal_put(impl_->db, m, error)) return false; - const std::wstring qv = quarantine_dir(impl_->folder) + L"\\" + m.new_v; + const std::wstring qv = joined(quarantine_dir(impl_->folder), m.new_v); if (!no_replace_move(source_video, qv)) { journal_clear(impl_->db, m.token, nullptr); if (error) @@ -852,7 +1021,7 @@ bool ClipDb::remove_clip(int64_t id, bool remove_files, std::string *error) { } if (have_thumb && !no_replace_move(impl_->thumb_path(thumb), - quarantine_dir(impl_->folder) + L"\\" + m.new_t)) { + joined(quarantine_dir(impl_->folder), m.new_t))) { if (!no_replace_move(qv, source_video)) { if (error) *error = "thumbnail move failed and video restore failed"; @@ -875,10 +1044,10 @@ bool ClipDb::remove_clip(int64_t id, bool remove_files, std::string *error) { std::error_code cleanup; fs::remove(qv, cleanup); if (have_thumb) - fs::remove(quarantine_dir(impl_->folder) + L"\\" + m.new_t, cleanup); + fs::remove(joined(quarantine_dir(impl_->folder), m.new_t), cleanup); if (path_exists(qv) || (have_thumb && - path_exists(quarantine_dir(impl_->folder) + L"\\" + m.new_t))) { + path_exists(joined(quarantine_dir(impl_->folder), m.new_t)))) { if (error) *error = "delete committed; quarantine cleanup deferred"; return false; @@ -887,6 +1056,12 @@ bool ClipDb::remove_clip(int64_t id, bool remove_files, std::string *error) { } bool ClipDb::set_favorite(int64_t id, bool favorite, std::string *error) { + MutationLock lock(impl_->db_path); + if (!lock.ok()) { + if (error) *error = "cannot acquire catalog mutation lock"; + return false; + } + sqlite3_stmt *st = nullptr; if (sqlite3_prepare_v2(impl_->db, "UPDATE clips SET favorite=? WHERE id=?", -1, &st, nullptr) != SQLITE_OK) { @@ -910,6 +1085,12 @@ bool ClipDb::set_favorite(int64_t id, bool favorite, std::string *error) { } bool ClipDb::set_duration(int64_t id, double seconds, std::string *error) { + MutationLock lock(impl_->db_path); + if (!lock.ok()) { + if (error) *error = "cannot acquire catalog mutation lock"; + return false; + } + sqlite3_stmt *st = nullptr; if (sqlite3_prepare_v2(impl_->db, "UPDATE clips SET duration_seconds=? WHERE id=?", -1, @@ -934,6 +1115,9 @@ bool ClipDb::set_duration(int64_t id, double seconds, std::string *error) { } std::wstring ClipDb::video_file_for(int64_t id) const { + MutationLock lock(impl_->db_path); + if (!lock.ok()) return {}; + std::wstring result; sqlite3_stmt *st = nullptr; if (sqlite3_prepare_v2(impl_->db, "SELECT video_file FROM clips WHERE id=?", @@ -951,6 +1135,12 @@ std::wstring ClipDb::video_file_for(int64_t id) const { bool ClipDb::add_bookmark(int64_t id, int seq, double time_seconds, const std::string &label, const std::string &color, std::string *error) { + MutationLock lock(impl_->db_path); + if (!lock.ok()) { + if (error) *error = "cannot acquire catalog mutation lock"; + return false; + } + if (!clip_exists(impl_->db, id)) { if (error) *error = "clip not found"; @@ -980,6 +1170,12 @@ bool ClipDb::add_bookmark(int64_t id, int seq, double time_seconds, bool ClipDb::update_bookmark(int64_t id, int seq, const std::string &label, const std::string &color, std::string *error) { + MutationLock lock(impl_->db_path); + if (!lock.ok()) { + if (error) *error = "cannot acquire catalog mutation lock"; + return false; + } + sqlite3_stmt *st = nullptr; if (sqlite3_prepare_v2(impl_->db, "UPDATE clip_bookmarks SET label=?, color=? WHERE " @@ -1007,6 +1203,12 @@ bool ClipDb::update_bookmark(int64_t id, int seq, const std::string &label, } bool ClipDb::remove_bookmark(int64_t id, int seq, std::string *error) { + MutationLock lock(impl_->db_path); + if (!lock.ok()) { + if (error) *error = "cannot acquire catalog mutation lock"; + return false; + } + sqlite3_stmt *st = nullptr; if (sqlite3_prepare_v2(impl_->db, "DELETE FROM clip_bookmarks WHERE clip_id=? AND seq=?", @@ -1026,6 +1228,12 @@ bool ClipDb::remove_bookmark(int64_t id, int seq, std::string *error) { bool ClipDb::set_bookmark_time(int64_t id, int seq, double time_seconds, std::string *error) { + MutationLock lock(impl_->db_path); + if (!lock.ok()) { + if (error) *error = "cannot acquire catalog mutation lock"; + return false; + } + sqlite3_stmt *st = nullptr; if (sqlite3_prepare_v2( impl_->db, @@ -1053,6 +1261,12 @@ bool ClipDb::set_bookmark_time(int64_t id, int seq, double time_seconds, bool ClipDb::list_bookmarks(int64_t id, std::vector &out, std::string *error) const { + MutationLock lock(impl_->db_path); + if (!lock.ok()) { + if (error) *error = "cannot acquire catalog mutation lock"; + return false; + } + out.clear(); sqlite3_stmt *st = nullptr; if (sqlite3_prepare_v2( @@ -1065,7 +1279,8 @@ bool ClipDb::list_bookmarks(int64_t id, std::vector &out, return false; } sqlite3_bind_int64(st, 1, id); - while (sqlite3_step(st) == SQLITE_ROW) { + int result = SQLITE_OK; + while ((result = sqlite3_step(st)) == SQLITE_ROW) { BookmarkRow row; row.seq = sqlite3_column_int(st, 0); row.time_seconds = sqlite3_column_double(st, 1); @@ -1075,12 +1290,19 @@ bool ClipDb::list_bookmarks(int64_t id, std::vector &out, row.color = reinterpret_cast(c); out.push_back(std::move(row)); } + if (result != SQLITE_DONE && error) *error = sqlite3_errmsg(impl_->db); sqlite3_finalize(st); - return true; + return result == SQLITE_DONE; } bool ClipDb::set_title(int64_t id, const std::string &title, std::string *error) { + MutationLock lock(impl_->db_path); + if (!lock.ok()) { + if (error) *error = "cannot acquire catalog mutation lock"; + return false; + } + const std::string value = title.empty() ? "Untitled" : title; sqlite3_stmt *st = nullptr; if (sqlite3_prepare_v2(impl_->db, "UPDATE clips SET title=? WHERE id=?", -1, @@ -1106,6 +1328,12 @@ bool ClipDb::set_title(int64_t id, const std::string &title, bool ClipDb::add_hashtag(int64_t id, const std::string &tag, std::string *error) { + MutationLock lock(impl_->db_path); + if (!lock.ok()) { + if (error) *error = "cannot acquire catalog mutation lock"; + return false; + } + if (tag.empty()) { if (error) *error = "empty tag"; @@ -1136,6 +1364,12 @@ bool ClipDb::add_hashtag(int64_t id, const std::string &tag, bool ClipDb::remove_hashtag(int64_t id, const std::string &tag, std::string *error) { + MutationLock lock(impl_->db_path); + if (!lock.ok()) { + if (error) *error = "cannot acquire catalog mutation lock"; + return false; + } + sqlite3_stmt *st = nullptr; if (sqlite3_prepare_v2(impl_->db, "DELETE FROM clip_hashtags WHERE clip_id=? AND tag=?", @@ -1154,6 +1388,12 @@ bool ClipDb::remove_hashtag(int64_t id, const std::string &tag, } bool ClipDb::regenerate_thumbnail(int64_t id, std::string *error) { + MutationLock lock(impl_->db_path); + if (!lock.ok()) { + if (error) *error = "cannot acquire catalog mutation lock"; + return false; + } + std::wstring video_base, thumb_base; { sqlite3_stmt *st = nullptr; @@ -1182,11 +1422,12 @@ bool ClipDb::regenerate_thumbnail(int64_t id, std::string *error) { std::error_code ec; fs::create_directories(impl_->thumbs_dir(), ec); + if (ec || !directory_valid(impl_->folder, impl_->thumbs_dir(), error)) return false; const std::wstring thumb = thumb_base.empty() ? thumb_basename_for(video_base) : thumb_base; const std::wstring vpath = impl_->video_path(video_base); const std::wstring tpath = impl_->thumb_path(thumb); - if (!fs::exists(vpath, ec)) { + if (!media_path_valid(impl_->folder, vpath, error)) { if (error) *error = "video file missing"; return false; @@ -1249,10 +1490,14 @@ bool ClipDb::rename_clip(int64_t id, const std::wstring &new_stem, *error = "clip not found or has invalid catalog paths"; return false; } + if (media_busy(impl_->folder, old_v, error) || shared_video(impl_->db, id, old_v, error) || + !media_path_valid(impl_->folder, impl_->video_path(old_v), error)) return false; const std::wstring new_v = new_stem + fs::path(old_v).extension().wstring(); const std::wstring old_thumb = old_t.empty() ? thumb_basename_for(old_v) : old_t; const bool have_thumb = path_exists(impl_->thumb_path(old_thumb)); + if (have_thumb && (!directory_valid(impl_->folder, impl_->thumbs_dir(), error) || + !media_path_valid(impl_->thumbs_dir(), impl_->thumb_path(old_thumb), error))) return false; const std::wstring new_t = have_thumb ? new_stem + L".png" : L""; if (path_exists(impl_->video_path(new_v)) || (!new_t.empty() && path_exists(impl_->thumb_path(new_t)))) { @@ -1317,6 +1562,138 @@ bool ClipDb::rename_clip(int64_t id, const std::wstring &new_stem, return journal_clear(impl_->db, m.token, error); } +bool ClipDb::capture_thumbnail(int64_t id, const std::wstring& upload_folder, + const std::string& token, std::string* error) { + MutationLock lock(impl_->db_path); + if (!lock.ok() || token.size() != 32 || !std::all_of(token.begin(), token.end(), + [](unsigned char c) { return std::isxdigit(c); })) { + if (error) *error = "invalid thumbnail token"; + return false; + } + const auto video = video_file_for(id); + if (!leaf(video) || media_busy(impl_->folder, video, error)) return false; + const auto upload = joined(upload_folder, utf8_to_wide(token + ".png")); + if (!directory_valid(fs::path(upload_folder).parent_path().wstring(), upload_folder, error) || + !media_path_valid(upload_folder, upload, error)) return false; + std::error_code ec; + const auto size = fs::file_size(upload, ec); + if (ec || size < 8 || size > 8 * 1024 * 1024) { if (error) *error = "invalid thumbnail size"; return false; } + std::ifstream input(fs::path(upload), std::ios::binary); + char signature[8]{}; + input.read(signature, 8); + if (!input || std::memcmp(signature, "\x89PNG\r\n\x1a\n", 8) != 0) { + if (error) *error = "invalid thumbnail PNG"; + return false; + } + fs::create_directories(impl_->thumbs_dir(), ec); + if (ec || !directory_valid(impl_->folder, impl_->thumbs_dir(), error)) return false; + const auto name = L"capture-" + utf8_to_wide(new_token()) + L".png"; + const auto target = impl_->thumb_path(name); + if (!fs::copy_file(upload, target, fs::copy_options::none, ec) || ec) { + if (error) *error = "cannot copy captured thumbnail"; + return false; + } + sqlite3_stmt* st = nullptr; + bool ok = sqlite3_prepare_v2(impl_->db, "UPDATE clips SET thumbnail_file=? WHERE id=?", -1, &st, nullptr) == SQLITE_OK; + const auto text = wide_to_utf8(name); + if (ok) { + sqlite3_bind_text(st, 1, text.c_str(), -1, SQLITE_TRANSIENT); sqlite3_bind_int64(st, 2, id); + ok = sqlite3_step(st) == SQLITE_DONE && sqlite3_changes(impl_->db) == 1; + } + sqlite3_finalize(st); + if (!ok) { if (error) *error = sqlite3_errmsg(impl_->db); fs::remove(target, ec); } + return ok; +} + +bool ClipDb::mutate_verified(int64_t id, const std::string& catalog_uid, + const std::string& clip_uid, int64_t revision, const std::function& mutation, + std::string* error) { + MutationLock lock(impl_->db_path); + if (!lock.ok()) { if (error) *error = "cannot acquire catalog mutation lock"; return false; } + sqlite3_stmt* st = nullptr; + if (sqlite3_prepare_v2(impl_->db, + "SELECT video_file,media_revision FROM clips WHERE id=? AND clip_uid=? " + "AND EXISTS(SELECT 1 FROM catalog_metadata WHERE key='catalog_uid' AND value=?)", + -1, &st, nullptr) != SQLITE_OK) { + if (error) *error = sqlite3_errmsg(impl_->db); + return false; + } + sqlite3_bind_int64(st, 1, id); + sqlite3_bind_text(st, 2, clip_uid.c_str(), -1, SQLITE_TRANSIENT); + sqlite3_bind_text(st, 3, catalog_uid.c_str(), -1, SQLITE_TRANSIENT); + const int result = sqlite3_step(st); + const auto video = result == SQLITE_ROW ? utf8_to_wide(reinterpret_cast(sqlite3_column_text(st, 0))) : std::wstring(); + const auto current = result == SQLITE_ROW ? sqlite3_column_int64(st, 1) : -1; + sqlite3_finalize(st); + if (result != SQLITE_ROW || (revision >= 0 && current != revision)) { + if (error) *error = "clip identity or media revision changed; refresh the library"; + return false; + } + if (!leaf(video) || media_busy(impl_->folder, video, error)) return false; + return mutation(); +} + +bool ClipDb::trim_clip(int64_t id, double start, double end, std::string* error) { + MutationLock lock(impl_->db_path); + if (!lock.ok() || !std::isfinite(start) || !std::isfinite(end) || start < 0 || end <= start) { + if (error) *error = "invalid trim interval or mutation lock failure"; + return false; + } + const auto video = video_file_for(id), path = impl_->video_path(video); + if (!leaf(video) || media_busy(impl_->folder, video, error) || + shared_video(impl_->db, id, video, error) || !media_path_valid(impl_->folder, path, error)) return false; + std::error_code ec; + const auto size = fs::file_size(path, ec); + if (ec) { if (error) *error = ec.message(); return false; } + const auto modified = fs::last_write_time(path, ec); + if (ec) { if (error) *error = ec.message(); return false; } + const auto token = new_token(); + const auto quarantine = quarantine_dir(impl_->folder); + fs::create_directories(quarantine, ec); + if (ec || !directory_valid(impl_->folder, quarantine, error)) return false; + const auto work = joined(quarantine, utf8_to_wide(token)); + if (!fs::create_directory(work, ec) || ec) { if (error) *error = "cannot create trim workspace"; return false; } + const auto backup = joined(work, L"original" + fs::path(video).extension().wstring()); + const auto temporary = joined(work, L"trimmed" + fs::path(video).extension().wstring()); + encoding::TrimResult retained; + bool ok = encoding::trim_clip_lossless(path, start, end, temporary, error, &retained); + if (!ok) ok = encoding::trim_clip_reencode(path, start, end, temporary, error, &retained); + if (!ok || !std::isfinite(retained.duration_seconds) || retained.duration_seconds <= 0) { + fs::remove_all(work, ec); return false; + } + if (!media_path_valid(impl_->folder, path, error) || fs::file_size(path, ec) != size || ec || + fs::last_write_time(path, ec) != modified || ec) { + if (error) *error = "clip changed during trim"; + fs::remove_all(work, ec); return false; + } + Mutation m{token, "trim", "prepared", id, video, fs::path(backup).filename().wstring(), + L"", fs::path(temporary).filename().wstring()}; + if (!journal_put(impl_->db, m, error)) { fs::remove_all(work, ec); return false; } + if (!no_replace_move(path, backup) || !no_replace_move(temporary, path)) { + if (error) *error = "cannot replace trim media; recovery retained"; + recover_mutations(impl_->db, impl_->folder, nullptr); return false; + } + std::vector bookmarks; + ok = list_bookmarks(id, bookmarks, error) && exec(impl_->db, "BEGIN IMMEDIATE", error); + if (ok) ok = set_duration(id, retained.duration_seconds, error); + for (const auto& b : bookmarks) { + if (!ok) break; + const auto shifted = retained.retime_bookmark(b.time_seconds); + ok = shifted ? set_bookmark_time(id, b.seq, *shifted, error) : remove_bookmark(id, b.seq, error); + } + if (ok) { + sqlite3_stmt* st = nullptr; + ok = sqlite3_prepare_v2(impl_->db, "UPDATE clips SET media_revision=media_revision+1 WHERE id=?", -1, &st, nullptr) == SQLITE_OK; + if (ok) { sqlite3_bind_int64(st, 1, id); ok = sqlite3_step(st) == SQLITE_DONE; } + sqlite3_finalize(st); + } + if (ok) ok = journal_stage(impl_->db, token, "committed", error) && exec(impl_->db, "COMMIT", error); + if (!ok) { exec(impl_->db, "ROLLBACK", nullptr); recover_mutations(impl_->db, impl_->folder, nullptr); return false; } + if (!recover_mutations(impl_->db, impl_->folder, error)) return false; + regenerate_thumbnail(id, nullptr); + return true; +} + ReconcileStats ClipDb::reconcile(std::string *error) { MutationLock lock(impl_->db_path); if (!lock.ok()) { @@ -1326,7 +1703,14 @@ ReconcileStats ClipDb::reconcile(std::string *error) { } ReconcileStats stats; std::error_code ec; + if (!fs::is_directory(impl_->folder, ec) || ec) { + if (error) *error = "catalog root is unavailable"; + return stats; + } + fs::directory_iterator visible(impl_->folder, ec); + if (ec) { if (error) *error = "cannot inspect catalog root: " + ec.message(); return stats; } fs::create_directories(impl_->thumbs_dir(), ec); + const bool thumbs_valid = !ec && directory_valid(impl_->folder, impl_->thumbs_dir(), error); // Snapshot rows first so we can mutate without invalidating a live cursor. struct Row { @@ -1340,7 +1724,8 @@ ReconcileStats ClipDb::reconcile(std::string *error) { if (sqlite3_prepare_v2(impl_->db, "SELECT id, video_file, thumbnail_file FROM clips", -1, &st, nullptr) == SQLITE_OK) { - while (sqlite3_step(st) == SQLITE_ROW) { + int result = SQLITE_OK; + while ((result = sqlite3_step(st)) == SQLITE_ROW) { Row r; r.id = sqlite3_column_int64(st, 0); if (const unsigned char *v = sqlite3_column_text(st, 1)) @@ -1349,9 +1734,14 @@ ReconcileStats ClipDb::reconcile(std::string *error) { r.thumb = utf8_to_wide(reinterpret_cast(t)); rows.push_back(std::move(r)); } + if (result != SQLITE_DONE) { + if (error) *error = sqlite3_errmsg(impl_->db); + sqlite3_finalize(st); return stats; + } sqlite3_finalize(st); - } else if (error) { - *error = sqlite3_errmsg(impl_->db); + } else { + if (error) *error = sqlite3_errmsg(impl_->db); + return stats; } } @@ -1362,17 +1752,27 @@ ReconcileStats ClipDb::reconcile(std::string *error) { continue; } const std::wstring vpath = impl_->video_path(r.video); - if (!fs::exists(vpath, ec)) { + const bool present = fs::exists(vpath, ec); + if (ec) { + if (error) *error = "cannot inspect catalog media: " + ec.message(); + known.insert(r.video); continue; + } + if (!present) { + if (!fs::is_directory(impl_->folder, ec) || ec) { + if (error) *error = "catalog root became unavailable"; + continue; + } if (remove_clip(r.id, /*remove_files=*/true, nullptr)) stats.removed++; continue; } known.insert(r.video); + if (encoding::media_is_owned(vpath) || !media_path_valid(impl_->folder, vpath, error)) continue; std::wstring thumb = r.thumb.empty() ? thumb_basename_for(r.video) : r.thumb; const std::wstring tpath = impl_->thumb_path(thumb); - if (!fs::exists(tpath, ec)) { + if (thumbs_valid && !fs::exists(tpath, ec) && !ec) { if (encoding::generate_thumbnail(vpath, tpath)) { // persist the (possibly new) thumbnail basename sqlite3_stmt *st = nullptr; @@ -1392,19 +1792,26 @@ ReconcileStats ClipDb::reconcile(std::string *error) { // Import orphan video files (migration of clips created before the DB). if (fs::is_directory(impl_->folder, ec)) { - for (const auto &entry : fs::directory_iterator(impl_->folder, ec)) { + fs::directory_iterator it(impl_->folder, ec), end; + if (ec) { if (error) *error = "cannot scan catalog root: " + ec.message(); return stats; } + for (; it != end; it.increment(ec)) { + if (ec) { if (error) *error = "catalog scan failed: " + ec.message(); break; } + const auto &entry = *it; if (!entry.is_regular_file(ec)) continue; const fs::path &p = entry.path(); if (!is_video_ext(p)) continue; const std::wstring base = p.filename().wstring(); - if (known.count(base)) - continue; + std::wstring lower = base; + std::transform(lower.begin(), lower.end(), lower.begin(), ::towlower); + if (known.count(base) || lower.find(L".trimming.") != std::wstring::npos || + lower.find(L".partial.") != std::wstring::npos || encoding::media_is_owned(p.wstring()) || + !media_path_valid(impl_->folder, p.wstring(), error)) continue; const std::wstring thumb = thumb_basename_for(base); std::wstring thumb_stored; - if (encoding::generate_thumbnail(impl_->video_path(base), + if (thumbs_valid && encoding::generate_thumbnail(impl_->video_path(base), impl_->thumb_path(thumb))) thumb_stored = thumb; @@ -1419,6 +1826,32 @@ ReconcileStats ClipDb::reconcile(std::string *error) { stats.imported++; } } + sqlite3_stmt* recovery = nullptr; + std::vector> recoverable; + if (sqlite3_prepare_v2(impl_->db, "SELECT id,video_file FROM clips", -1, &recovery, nullptr) == SQLITE_OK) { + while (sqlite3_step(recovery) == SQLITE_ROW) { + const auto* name = sqlite3_column_text(recovery, 1); + if (name) recoverable.emplace_back(sqlite3_column_int64(recovery, 0), utf8_to_wide(reinterpret_cast(name))); + } + } + sqlite3_finalize(recovery); + for (const auto& [id, video] : recoverable) { + const auto media = impl_->video_path(video); + std::error_code journal_error; + if (!leaf(video) || encoding::media_is_owned(media) || + !fs::exists(recording::bookmark_journal_path(media), journal_error) || journal_error) continue; + std::vector recovered; + std::string detail; + bool ok = recording::read_bookmark_journal(media, recovered, &detail); + int seq = 1; + for (const auto& b : recovered) { + if (!ok) break; + ok = add_bookmark(id, seq++, b.time_seconds, b.label, b.color, &detail); + } + if (ok) fs::remove(recording::bookmark_journal_path(media), journal_error); + else if (error) *error = "bookmark recovery failed: " + detail; + } + if (ec && error) *error = "catalog scan failed: " + ec.message(); return stats; } diff --git a/libs/storage/storage.h b/libs/storage/storage.h index b64edd3..98541a4 100644 --- a/libs/storage/storage.h +++ b/libs/storage/storage.h @@ -3,6 +3,7 @@ #include #include #include +#include #include #include @@ -121,6 +122,13 @@ class ClipDb { // File rename is separate from the display title. bool rename_clip(int64_t id, const std::wstring& new_stem, std::string* error); + bool mutate_verified(int64_t id, const std::string& catalog_uid, + const std::string& clip_uid, int64_t revision, + const std::function& mutation, std::string* error); + bool trim_clip(int64_t id, double start, double end, std::string* error); + bool capture_thumbnail(int64_t id, const std::wstring& upload_folder, + const std::string& token, std::string* error); + // Reconcile absent media, missing thumbnails and uncataloged files on a background worker. ReconcileStats reconcile(std::string* error); diff --git a/tests/u6/CMakeLists.txt b/tests/u6/CMakeLists.txt index 186345e..bf42751 100644 --- a/tests/u6/CMakeLists.txt +++ b/tests/u6/CMakeLists.txt @@ -3,9 +3,10 @@ project(monolith_u6_tests LANGUAGES CXX) set(CMAKE_CXX_STANDARD 23) enable_testing() find_package(PkgConfig REQUIRED) +find_package(nlohmann_json CONFIG REQUIRED) pkg_check_modules(SQLITE REQUIRED IMPORTED_TARGET sqlite3) add_executable(storage_mutation_test storage_mutation_test.cpp ../../libs/storage/storage.cpp) target_include_directories(storage_mutation_test PRIVATE ../../libs win32-shim) target_compile_options(storage_mutation_test PRIVATE -Wall -Wextra -Wpedantic) -target_link_libraries(storage_mutation_test PRIVATE PkgConfig::SQLITE) +target_link_libraries(storage_mutation_test PRIVATE PkgConfig::SQLITE nlohmann_json::nlohmann_json) add_test(NAME storage_mutation COMMAND storage_mutation_test) diff --git a/tests/u6/storage_mutation_test.cpp b/tests/u6/storage_mutation_test.cpp index 4e018f0..4324519 100644 --- a/tests/u6/storage_mutation_test.cpp +++ b/tests/u6/storage_mutation_test.cpp @@ -1,4 +1,7 @@ #include +#include +#include +#include #include #include #include @@ -15,6 +18,13 @@ namespace encoding { bool generate_thumbnail(const std::wstring &, const std::wstring &, int) { return false; } +bool trim_clip_lossless(const std::wstring& path, double start, double end, + const std::wstring& out, std::string*, TrimResult* result) { + fs::copy_file(path, out, fs::copy_options::overwrite_existing); + *result = {start, end-start}; return true; +} +bool trim_clip_reencode(const std::wstring&, double, double, + const std::wstring&, std::string*, TrimResult*) { return false; } } // namespace encoding static void check(bool v, const char *m) { if (!v) @@ -31,19 +41,28 @@ static void sql(const fs::path &db, const char *q) { sqlite3_free(e); sqlite3_close(x); } +static std::string scalar(const fs::path& path, const char* query) { + sqlite3* db = nullptr; sqlite3_stmt* st = nullptr; + check(sqlite3_open(path.string().c_str(), &db) == SQLITE_OK, "open scalar"); + check(sqlite3_prepare_v2(db, query, -1, &st, nullptr) == SQLITE_OK, "prepare scalar"); + check(sqlite3_step(st) == SQLITE_ROW, "read scalar"); + const auto* value = sqlite3_column_text(st, 0); + std::string result = value ? reinterpret_cast(value) : ""; + sqlite3_finalize(st); sqlite3_close(db); return result; +} int main() { try { auto root = fs::temp_directory_path() / "monolith-u6-storage"; fs::remove_all(root); fs::create_directories(root / ".thumbs"); auto folder = root.wstring(); - fs::remove(fs::path(folder + L"\\clips.db")); - fs::remove_all(fs::path(folder + L"\\.monolith-mutations")); + fs::remove(fs::path((root / L"clips.db").wstring())); + fs::remove_all(fs::path((root / L".monolith-mutations").wstring())); std::string e; auto db = storage::ClipDb::open(folder, "replay", &e); check(db != nullptr, "open1"); - touch(folder + L"\\a.mp4"); - touch(folder + L"\\.thumbs\\a.png"); + touch((root / L"a.mp4").wstring()); + touch((root / L".thumbs/a.png").wstring()); storage::ClipRow r; r.video_file = L"a.mp4"; r.thumbnail_file = L"a.png"; @@ -51,44 +70,44 @@ int main() { auto id = db->insert_clip(r, &e); check(id > 0, e.c_str()); check(db->rename_clip(id, L"b", &e), e.c_str()); - check(fs::exists(folder + L"\\b.mp4"), "renamed video"); + check(fs::exists((root / L"b.mp4").wstring()), "renamed video"); check(db->remove_clip(id, true, &e), e.c_str()); - check(!fs::exists(folder + L"\\b.mp4"), "deleted video"); + check(!fs::exists((root / L"b.mp4").wstring()), "deleted video"); db.reset(); // Prepared delete: video resides in exact quarantine target and is restored // at open. - touch(folder + L"\\p.mp4"); + touch((root / L"p.mp4").wstring()); db = storage::ClipDb::open(folder, "replay", &e); r.video_file = L"p.mp4"; r.thumbnail_file = L""; id = db->insert_clip(r, &e); db.reset(); - fs::create_directories(folder + L"\\.monolith-mutations"); - fs::rename(folder + L"\\p.mp4", - folder + L"\\.monolith-mutations\\1234567890abcdef-video"); - auto path = fs::path(folder + L"\\clips.db"); + fs::create_directories((root / L".monolith-mutations").wstring()); + fs::rename((root / L"p.mp4").wstring(), + (root / L".monolith-mutations/1234567890abcdef-video").wstring()); + auto path = fs::path((root / L"clips.db").wstring()); sql(path, "INSERT INTO file_mutation_journal VALUES " - "('1234567890abcdef',1,'delete',2,'p.mp4','1234567890abcdef-" + "('1234567890abcdef',1,'delete',1,'p.mp4','1234567890abcdef-" "video','','','prepared');"); db = storage::ClipDb::open(folder, "replay", &e); if (!db) std::cerr << "prepared delete: " << e << "\n"; check(db != nullptr, "open2"); - check(fs::exists(folder + L"\\p.mp4"), "prepared delete restore"); + check(fs::exists((root / L"p.mp4").wstring()), "prepared delete restore"); db.reset(); // Prepared rename restores the old name; a committed delete removes only // its quarantine file. - fs::rename(folder + L"\\p.mp4", folder + L"\\q.mp4"); + fs::rename((root / L"p.mp4").wstring(), (root / L"q.mp4").wstring()); sql(path, "INSERT INTO file_mutation_journal VALUES " - "('abcdef1234567890',1,'rename',2,'p.mp4','q.mp4','','','prepared');"); + "('abcdef1234567890',1,'rename',1,'p.mp4','q.mp4','','','prepared');"); db = storage::ClipDb::open(folder, "replay", &e); if (!db) std::cerr << "prepared rename: " << e << "\n"; check(db != nullptr, "open3"); - check(fs::exists(folder + L"\\p.mp4"), "prepared rename restore"); + check(fs::exists((root / L"p.mp4").wstring()), "prepared rename restore"); db.reset(); - touch(folder + L"\\.monolith-mutations\\fedcba0987654321-video"); + touch((root / L".monolith-mutations/fedcba0987654321-video").wstring()); sql(path, "INSERT INTO file_mutation_journal VALUES " "('fedcba0987654321',1,'delete',8,'gone.mp4','fedcba0987654321-" "video','','','committed');"); @@ -97,12 +116,12 @@ int main() { std::cerr << "committed: " << e << "\n"; check(db != nullptr, "open4"); check( - !fs::exists(folder + L"\\.monolith-mutations\\fedcba0987654321-video"), + !fs::exists((root / L".monolith-mutations/fedcba0987654321-video").wstring()), "committed cleanup"); db.reset(); // Both paths present is ambiguous and fails closed. - touch(folder + L"\\amb.mp4"); - touch(folder + L"\\amb-new.mp4"); + touch((root / L"amb.mp4").wstring()); + touch((root / L"amb-new.mp4").wstring()); sql(path, "INSERT INTO file_mutation_journal VALUES " "('1122334455667788',1,'rename',9,'amb.mp4','amb-new.mp4','','','" "prepared');"); @@ -115,6 +134,55 @@ int main() { check(db != nullptr, "open after ambiguous recovery"); check(!db->rename_clip(1, L"..", &e), "parent alias rejected"); check(!db->rename_clip(1, L"trailing ", &e), "trailing space rejected"); + const auto uid = scalar(path, "SELECT value FROM catalog_metadata WHERE key='catalog_uid'"); + const auto clip_uid = scalar(path, "SELECT clip_uid FROM clips WHERE id=1"); + check(!db->mutate_verified(id, "other", clip_uid, 0, [] { return true; }, &e), "wrong catalog rejected"); + check(!db->mutate_verified(id, uid, "other", 0, [] { return true; }, &e), "wrong clip rejected"); + check(db->mutate_verified(id, uid, clip_uid, 0, [] { return true; }, &e), "matching identity accepted"); + { + encoding::MediaWriteGuard owner((root / "p.mp4").wstring()); + check(!db->remove_clip(id, true, &e), "owned media cannot be deleted"); + check(!db->trim_clip(id, 1, 3, &e), "owned media cannot be trimmed"); + } + check(db->add_bookmark(id, 1, 2, "kept", "red", &e), "seed bookmark"); + check(db->add_bookmark(id, 2, 8, "removed", "red", &e), "seed outside bookmark"); + check(db->trim_clip(id, 1, 4, &e), e.c_str()); + check(scalar(path, "SELECT media_revision FROM clips WHERE id=1") == "1", "trim increments revision"); + check(!db->mutate_verified(id, uid, clip_uid, 0, [] { return true; }, &e), "stale timeline rejected"); + std::vector bookmarks; + check(db->list_bookmarks(id, bookmarks, &e) && bookmarks.size() == 1 && bookmarks[0].time_seconds == 1, "trim retimes bookmarks"); + check(scalar(path, "SELECT count(*) FROM file_mutation_journal") == "0", "trim cleanup"); + sql(path, "CREATE TRIGGER fail_trim BEFORE UPDATE OF duration_seconds ON clips BEGIN SELECT RAISE(ABORT,'injected'); END;"); + check(!db->trim_clip(id, 0, 1, &e), "metadata failure rejects trim"); + check(fs::exists(root / "p.mp4"), "failed trim restores original"); + check(scalar(path, "SELECT media_revision FROM clips WHERE id=1") == "1", "failed trim preserves revision"); + sql(path, "DROP TRIGGER fail_trim;"); + check(recording::write_bookmark_journal((root / "p.mp4").wstring(), {{0.5,"recovered","red"}}, &e), "write recovery sidecar"); + db->reconcile(&e); + check(db->list_bookmarks(id, bookmarks, &e) && bookmarks.size() == 1 && bookmarks[0].label == "recovered", "recover sidecar bookmarks"); + check(!fs::exists(recording::bookmark_journal_path((root / "p.mp4").wstring())), "remove completed sidecar"); + db.reset(); + const auto work = root / ".monolith-mutations" / "aabbccddeeff0011"; + fs::create_directories(work); + fs::rename(root / "p.mp4", work / "original.mp4"); + touch((root / "p.mp4").wstring()); + sql(path, "INSERT INTO file_mutation_journal VALUES ('aabbccddeeff0011',1,'trim',1,'p.mp4','original.mp4','','trimmed.mp4','prepared');"); + db = storage::ClipDb::open(folder, "replay", &e); + check(db != nullptr && fs::exists(root / "p.mp4") && !fs::exists(work), "interrupted trim restores and cleans"); + fs::create_symlink(root / "p.mp4", root / "linked.mp4"); + r.video_file = L"linked.mp4"; + const auto linked_id = db->insert_clip(r, &e); + check(linked_id > 0 && !db->trim_clip(linked_id, 0, 1, &e), "trim rejects symlink"); + db.reset(); + db = storage::ClipDb::open(folder, "replay", &e); + check(db != nullptr, "open for thumbnail capture"); + fs::create_directories(root / "upload"); + const std::string token(32, 'a'); + std::ofstream(root / "upload" / (token+".png"), std::ios::binary).write("\x89PNG\r\n\x1a\n", 8); + check(!db->capture_thumbnail(id, (root / "upload").wstring(), "../invalid", &e), "thumbnail traversal token rejected"); + check(db->capture_thumbnail(id, (root / "upload").wstring(), token, &e), e.c_str()); + check(scalar(path, "SELECT thumbnail_file FROM clips WHERE id=1").starts_with("capture-"), "captured thumbnail published"); + db.reset(); // Invalid journal is rejected rather than interpreted. sql(path, "INSERT INTO file_mutation_journal VALUES " "('bad',1,'delete',3,'../x','q','','','prepared');"); From bc34c68c6f304354fc1af678a45d722d642a99b1 Mon Sep 17 00:00:00 2001 From: fraa2a Date: Fri, 9 Oct 2026 16:54:28 +0200 Subject: [PATCH 10/14] fix(ui): align media protocol configuration and timeline regression fixture --- app/desktop-ui/src-tauri/tauri.conf.json | 6 +----- app/desktop-ui/tests/audit.mjs | 2 +- 2 files changed, 2 insertions(+), 6 deletions(-) diff --git a/app/desktop-ui/src-tauri/tauri.conf.json b/app/desktop-ui/src-tauri/tauri.conf.json index d403c7f..0d2d6e1 100644 --- a/app/desktop-ui/src-tauri/tauri.conf.json +++ b/app/desktop-ui/src-tauri/tauri.conf.json @@ -12,11 +12,7 @@ "app": { "windows": [], "security": { - "csp": "default-src 'self'; img-src 'self' media: http://media.localhost data:; media-src 'self' media: http://media.localhost; connect-src 'self' ipc: http://ipc.localhost; style-src 'self' 'unsafe-inline'", - "assetProtocol": { - "enable": false, - "scope": [] - } + "csp": "default-src 'self'; img-src 'self' media: http://media.localhost data:; media-src 'self' media: http://media.localhost; connect-src 'self' ipc: http://ipc.localhost; style-src 'self' 'unsafe-inline'" } }, "bundle": { diff --git a/app/desktop-ui/tests/audit.mjs b/app/desktop-ui/tests/audit.mjs index b817807..46078c3 100644 --- a/app/desktop-ui/tests/audit.mjs +++ b/app/desktop-ui/tests/audit.mjs @@ -237,7 +237,7 @@ try { assert.equal(await page.evaluate(()=>window.__uiTest.calls.filter(c=>c.command==='collection_memberships').length),1); }); await check('S03 timeline mutations use the clip media revision',async()=>{ - await page.evaluate(()=>{window.__uiTest.clips[0].media_revision=7;window.__uiTest.emit();}); + await page.evaluate(()=>{window.__uiTest.clips[0].media_revision=7;window.__uiTest.clips[0].source="manual";window.__uiTest.emit();}); await page.getByRole('button',{name:'Open Match 01',exact:true}).click(); await page.evaluate(()=>{Object.defineProperty(HTMLMediaElement.prototype,'duration',{get:()=>30});document.querySelector('.detail video').dispatchEvent(new Event('loadedmetadata'));}); await page.getByTitle('Add bookmark at current time',{exact:true}).click(); From 81663d028388395c3d50acf06e2f82963082a9ca Mon Sep 17 00:00:00 2001 From: fraa2a Date: Fri, 9 Oct 2026 16:54:40 +0200 Subject: [PATCH 11/14] fix(recorder): preserve session publication and wire guarded media commands --- app/recorder/src/main.cpp | 456 +++++++++++++-------------- libs/disk-segments/disk_segments.cpp | 4 + libs/disk-segments/disk_segments.h | 1 + libs/ipc/ipc_server.cpp | 22 +- libs/ipc/ipc_server.h | 10 +- libs/recording/recording.cpp | 10 +- libs/replay-buffer/replay_buffer.cpp | 7 + libs/replay-buffer/replay_buffer.h | 1 + tests/phase1/ipc_server_test.cpp | 21 +- 9 files changed, 289 insertions(+), 243 deletions(-) diff --git a/app/recorder/src/main.cpp b/app/recorder/src/main.cpp index ba17042..a221934 100644 --- a/app/recorder/src/main.cpp +++ b/app/recorder/src/main.cpp @@ -24,6 +24,11 @@ #include #include #include +#include +#include +#include +#include +#include #include #include @@ -45,6 +50,8 @@ #include #include #include +#include +#include #include #include #include @@ -282,6 +289,7 @@ struct PacerFrame { static PacerFrame g_pacer_shared; static int64_t g_pacer_qpc_freq = 0; // QueryPerformanceFrequency +static std::atomic g_audio_origin_100ns{0}; static int64_t g_pacer_start_qpc = 0; // QPC at pacer start static int64_t g_pacer_frames_done = 0; // CFR frames emitted so far static int g_pacer_fps = 0; @@ -573,6 +581,8 @@ static void pacer_start() QueryPerformanceCounter(&start); g_pacer_qpc_freq = freq.QuadPart; g_pacer_start_qpc = start.QuadPart; + g_audio_origin_100ns.store((start.QuadPart / freq.QuadPart) * 10000000 + + (start.QuadPart % freq.QuadPart) * 10000000 / freq.QuadPart); g_pacer_frames_done = 0; g_pacer_time_period_set = false; @@ -741,11 +751,11 @@ static void load_app_settings() log_path("settings", "config path: ", g_settings.user_config_path); } -// Blocking thumbnail/catalog work runs off the tray thread. Invoke on_cataloged -// after insertion to flush pending manual-recording bookmarks. +// Thumbnail/catalog work runs off the tray thread. +static recording::BoundedWorker g_catalog_worker(64, 0); + static int64_t catalog_clip(std::wstring video_path, std::string source, - double duration_seconds, - std::function on_cataloged = {}) + double duration_seconds) { if (video_path.empty()) return -1; std::error_code ec; @@ -797,16 +807,15 @@ static int64_t catalog_clip(std::wstring video_path, std::string source, } g_clip_generation.fetch_add(1, std::memory_order_relaxed); log_path("storage", "clip cataloged: ", base); - if (on_cataloged) on_cataloged(row_id); return row_id; } -// Reconcile catalogs on a detached worker; startup does not wait for it. +// Reconciliation shares the owned catalog worker. static void reconcile_catalogs() { const std::wstring clips_dir = g_settings.clips_directory; const std::wstring recs_dir = g_settings.recordings_directory; - std::thread([clips_dir, recs_dir]() { + g_catalog_worker.submit([clips_dir, recs_dir]() { auto run = [](const std::wstring& folder, const char* source) { if (folder.empty()) return; std::string error; @@ -825,184 +834,164 @@ static void reconcile_catalogs() }; run(clips_dir, "replay"); run(recs_dir, "manual"); - }).detach(); + }); } // Timestamp live bookmarks during recording, then attach them after the clip row is inserted. -struct PendingBookmark { - double time_seconds; - std::string label; - std::string color; -}; -static std::mutex g_pending_bookmarks_mutex; -static std::vector g_pending_bookmarks; - -static void clear_pending_bookmarks() -{ - std::lock_guard lk(g_pending_bookmarks_mutex); - g_pending_bookmarks.clear(); -} +static recording::SessionBatch g_bookmarks; +static void clear_pending_bookmarks() { g_bookmarks.begin(); } -// Runs on the manual-stop catalog thread (off the UI/tray loop). -static void flush_pending_bookmarks(int64_t clip_id, const std::wstring& folder) -{ - // Validate before swapping: the swap consumes the queue, and losing the - // bookmarks because the clip row is missing would be silent data loss. - if (clip_id <= 0) { - log_msg("storage", "bookmark flush skipped: clip row missing"); - return; - } - std::vector pending; - { - std::lock_guard lk(g_pending_bookmarks_mutex); - pending.swap(g_pending_bookmarks); - } - if (pending.empty()) return; +static bool flush_bookmarks(int64_t id, const std::wstring& folder, + const std::vector& bookmarks) { std::string error; auto db = storage::ClipDb::open(folder, "manual", &error); - if (!db) { - log_msg("storage", ("bookmark flush failed: clip DB open failed: " + error).c_str()); - return; - } + if (!db || id <= 0) return false; int seq = 1; - for (const auto& bm : pending) { - if (!db->add_bookmark(clip_id, seq++, bm.time_seconds, bm.label, bm.color, &error)) - log_msg("storage", ("bookmark insert failed: " + error).c_str()); - } - log_msg("storage", ("flushed " + std::to_string(pending.size()) + " bookmark(s)").c_str()); + for (const auto& b : bookmarks) + if (!db->add_bookmark(id, seq++, b.time_seconds, b.label, b.color, &error)) { + log_error("storage", error.c_str()); return false; + } + return true; } -// Timestamps and queues one bookmark for the running manual recording. Shared -// by the IPC handler (IPC thread) and the tray/hotkey path (UI thread) - all -// state touched is atomic or mutex-guarded. Returns "" on success. -static std::string add_bookmark_now() -{ - const recording::RecordingState st = g_recording.state(); - if (st != recording::RecordingState::Recording) - return st == recording::RecordingState::Paused ? "recording is paused" - : "not recording"; - const double t = recording_elapsed_seconds(); - { - std::lock_guard lk(g_pending_bookmarks_mutex); - g_pending_bookmarks.push_back({ - t, - "Bookmark " + std::to_string(g_pending_bookmarks.size() + 1), - "#f59e0b", +struct Publication { + recording::FinalizationState state; + recording::SessionBatch::Batch batch; + std::shared_ptr owner; + bool queued = false; + std::string error; +}; +static std::mutex g_publication_mutex; +static std::vector> g_publications; + +static void retry_publications() { + std::lock_guard lock(g_publication_mutex); + for (const auto& item : g_publications) { + if (item->queued) continue; + item->queued = true; + const bool queued = g_catalog_worker.submit([item] { + std::string failure; + try { + recording::finalize_once(item->state, [] { return std::wstring{}; }, [&](const auto& path) { + std::string error; + if (!recording::write_bookmark_journal(path, item->batch.items, &error)) + throw std::runtime_error(error); + if (std::filesystem::path(path).extension() == L".failed") return; + const auto id = catalog_clip(path, "manual", 0.0); + if (id <= 0 || !flush_bookmarks(id, std::filesystem::path(path).parent_path().wstring(), item->batch.items)) + throw std::runtime_error("Recording publication failed; bookmarks retained for retry."); + std::error_code ec; + std::filesystem::remove(recording::bookmark_journal_path(path), ec); + }); + } catch (const std::exception& e) { failure = e.what(); } + std::lock_guard done(g_publication_mutex); + item->error = failure; + item->queued = false; + if (failure.empty()) std::erase(g_publications, item); + else log_error("storage", failure.c_str()); }); + if (!queued) item->queued = false; } - feedback::play(feedback::Sound::ClipSaved); +} +static bool publication_blocks_start() { + retry_publications(); + std::lock_guard lock(g_publication_mutex); + return !g_publications.empty(); +} +static std::string publication_error() { + std::lock_guard lock(g_publication_mutex); + for (const auto& p : g_publications) if (!p->error.empty()) return p->error; return {}; } - -// Trim into a sibling file, replace the media, then retime bookmarks and refresh the thumbnail. -static std::string trim_clip(storage::ClipDb* db, - const std::wstring& folder, - int64_t id, double start, double end) -{ - if (!std::isfinite(start) || !std::isfinite(end) || start < 0.0 || end <= start) - return "end must be after start"; - - std::string err; - const std::wstring video_file = db->video_file_for(id); - if (video_file.empty()) return "clip not found"; - const std::wstring video_path = folder + L"\\" + video_file; - const std::filesystem::path p(video_path); - const std::wstring ext = p.extension().wstring(); // ".mkv" | ".mp4" - const double duration = encoding::probe_duration_seconds(video_path); - if (duration <= 0.0) return "could not read clip duration"; - if (start >= duration) return "start is past the end of the clip"; - const double eff_end = std::min(end, duration); - - // Keep the original media while producing the sibling trim file. - std::wstring stem = p.stem().wstring(); - if (stem.empty()) stem = L"clip"; - const std::wstring tmp_path = folder + L"\\" + stem + L".trimming" + ext; - - encoding::TrimResult retained; - bool ok = encoding::trim_clip_lossless(video_path, start, eff_end, tmp_path, &err, &retained); - if (!ok) - ok = encoding::trim_clip_reencode(video_path, start, eff_end, tmp_path, &err, &retained); - if (!ok) { - std::error_code ec; - std::filesystem::remove(tmp_path, ec); - return "trim failed: " + err; +static void publish_recording(const std::wstring& path, + recording::SessionBatch::Batch batch, + std::shared_ptr owner) { + if (path.empty()) return; + auto item = std::make_shared(); + item->state = {path, true, false}; + item->batch = std::move(batch); item->owner = std::move(owner); + { + std::lock_guard lock(g_publication_mutex); + g_publications.push_back(std::move(item)); } + retry_publications(); +} + +static std::string add_bookmark_now() { + const auto session = g_bookmarks.id(); + const auto st = g_recording.state(); + if (!session) return "not recording"; + if (st != recording::RecordingState::Recording) return "not recording"; + if (!g_bookmarks.add({recording_elapsed_seconds(), "Bookmark", "#f59e0b"}, session)) + return "recording session changed or bookmark limit reached"; + feedback::play(feedback::Sound::ClipSaved); + return {}; +} - // Replace the original (MOVEFILE_REPLACE_EXISTING is atomic on the same - // volume - same folder here). - if (!MoveFileExW(tmp_path.c_str(), video_path.c_str(), - MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH)) { +static bool finish_recording() { + if (g_recording.state() == recording::RecordingState::Idle) return false; + const auto original = g_recording.current_path(); + auto owner = std::make_shared(original); + std::wstring path; + g_recording.stop(&path); + rec_clock_stop(); + auto batch = g_bookmarks.finish(); + if (path.empty()) { std::error_code ec; - std::filesystem::remove(tmp_path, ec); - return "trim failed: could not replace clip file"; - } - - const double new_duration = retained.duration_seconds; - if (!db->set_duration(id, new_duration, &err)) - return "trim succeeded but duration update failed: " + err; - - // Retime from the actual retained presentation anchor, not the requested - // non-keyframe cut. Filesystem/DB durability is phase 2B; report failures. - std::vector bookmarks; - if (!db->list_bookmarks(id, bookmarks, &err)) - return "trim succeeded but bookmark read failed: " + err; - for (const auto& bm : bookmarks) { - const auto shifted = retained.retime_bookmark(bm.time_seconds); - const bool updated = shifted - ? db->set_bookmark_time(id, bm.seq, *shifted, &err) - : db->remove_bookmark(id, bm.seq, &err); - if (!updated) return "trim succeeded but bookmark update failed: " + err; - } - - // Refresh the thumbnail and notify the UI after replacing the media. - if (db->regenerate_thumbnail(id, &err)) { - g_clip_generation.fetch_add(1, std::memory_order_relaxed); - } else { - // Retain the previous thumbnail when regeneration fails. - log_error("storage", ("clip_trim thumbnail regen failed: " + err).c_str()); - g_clip_generation.fetch_add(1, std::memory_order_relaxed); + const auto partial = original + L".failed"; + if (std::filesystem::is_regular_file(partial, ec) && !ec) { + path = partial; + owner = std::make_shared(partial); + } } - return {}; + publish_recording(path, std::move(batch), std::move(owner)); + return true; } -// Catalog mutations run on IPC threads and return an empty string or an error. -static std::string handle_clip_mutation(const ipc::ClipMutation& m) -{ +static std::string handle_clip_mutation(const ipc::ClipMutation& m) { std::wstring folder; { std::lock_guard lk(g_dirs_mutex); folder = (m.source == "manual") ? g_recs_dir_snapshot : g_clips_dir_snapshot; } - if (m.source != "replay" && m.source != "manual") - return "invalid clip source"; + if (m.source != "replay" && m.source != "manual") return "invalid clip source"; if (folder.empty()) return "output folder unknown"; - - std::string err; - auto db = storage::ClipDb::open(folder, m.source, &err); - if (!db) return "clip DB open failed: " + err; - - if (m.method == "clip_trim") { - return trim_clip(db.get(), folder, m.id, m.start, m.end); - } - - bool ok = false; - if (m.method == "clip_set_favorite") ok = db->set_favorite(m.id, m.favorite, &err); - else if (m.method == "clip_add_hashtag") ok = db->add_hashtag(m.id, m.tag, &err); - else if (m.method == "clip_remove_hashtag") ok = db->remove_hashtag(m.id, m.tag, &err); - else if (m.method == "clip_rename") ok = db->rename_clip(m.id, utf8_to_wide(m.new_name), &err); - else if (m.method == "clip_set_title") ok = db->set_title(m.id, m.title, &err); - else if (m.method == "clip_regen_thumb") ok = db->regenerate_thumbnail(m.id, &err); - else if (m.method == "clip_delete") ok = db->remove_clip(m.id, /*remove_files=*/true, &err); - else return "unknown mutation: " + m.method; - - if (!ok) { - log_error("storage", ("clip mutation '" + m.method + "' failed: " + err).c_str()); - } else if (m.method == "clip_regen_thumb") { - // Notify the UI after changing a thumbnail without inserting a clip row. - g_clip_generation.fetch_add(1, std::memory_order_relaxed); - } - - return ok ? std::string() : err; + std::string error; + auto db = storage::ClipDb::open(folder, m.source, &error); + if (!db) return error; + const bool timeline = m.method == "clip_trim" || m.method == "clip_add_bookmark" || + m.method == "clip_update_bookmark" || m.method == "clip_delete_bookmark" || m.method == "clip_capture_thumb" || m.method == "clip_set_duration"; + if (timeline && m.media_revision < 0) return "media revision required"; + const bool ok = db->mutate_verified(m.id, m.catalog_uid, m.clip_uid, + timeline ? m.media_revision : -1, [&] { + if (m.method == "clip_set_duration") { + if (!std::isfinite(m.duration) || m.duration <= 0 || m.duration > 1e9) { error = "invalid clip duration"; return false; } + return db->set_duration(m.id, m.duration, &error); + } + if (m.method == "clip_capture_thumb") return db->capture_thumbnail(m.id, + (std::filesystem::path(known_folder_path(FOLDERID_LocalAppData)) / L"Monolith" / L"thumb-upload").wstring(), m.upload_token, &error); + if (m.method == "clip_trim") return db->trim_clip(m.id, m.start, m.end, &error); + if (m.method == "clip_set_favorite") return db->set_favorite(m.id, m.favorite, &error); + if (m.method == "clip_add_hashtag") return db->add_hashtag(m.id, m.tag, &error); + if (m.method == "clip_remove_hashtag") return db->remove_hashtag(m.id, m.tag, &error); + if (m.method == "clip_rename") return db->rename_clip(m.id, utf8_to_wide(m.new_name), &error); + if (m.method == "clip_set_title") return db->set_title(m.id, m.title, &error); + if (m.method == "clip_regen_thumb") return db->regenerate_thumbnail(m.id, &error); + if (m.method == "clip_delete") return db->remove_clip(m.id, true, &error); + if (m.method == "clip_update_bookmark") return db->update_bookmark(m.id, m.seq, m.label, m.color, &error); + if (m.method == "clip_delete_bookmark") return db->remove_bookmark(m.id, m.seq, &error); + if (m.method == "clip_add_bookmark") { + if (!std::isfinite(m.time_seconds) || m.time_seconds < 0) { error = "invalid bookmark time"; return false; } + std::vector rows; + if (!db->list_bookmarks(m.id, rows, &error)) return false; + int seq = 1; + for (const auto& b : rows) seq = std::max(seq, b.seq + 1); + return db->add_bookmark(m.id, seq, m.time_seconds, m.label, m.color, &error); + } + error = "unknown mutation"; return false; + }, &error); + if (ok) g_clip_generation.fetch_add(1); + return ok ? std::string{} : error; } // media_start/media_stop are defined far below; forward-declare them here since @@ -1010,6 +999,7 @@ static std::string handle_clip_mutation(const ipc::ClipMutation& m) static void media_start(HWND hwnd); static void media_stop(); static void tray_set_recording(bool recording); +static void apply_pending_media(HWND hwnd); // Detection, selection and auto-record state below belong to the tray thread. static uint64_t g_last_game_seen_ms = 0; @@ -1048,11 +1038,12 @@ static std::string exe_key_of(const std::wstring& process_name) // true when a recording was started. static bool auto_record_start(HWND hwnd) { - if (!g_settings.capture_auto_record) return false; + if (!g_settings.capture_auto_record || publication_blocks_start()) return false; if (!g_recording_enabled.load(std::memory_order_relaxed)) return false; if (g_recording.state() != recording::RecordingState::Idle) return false; - if (!g_video.running()) media_start(hwnd); if (!g_recording.start(g_recordings_dir, g_recording_container)) return false; + if (!g_video.running()) media_start(hwnd); + if (!g_video.running()) { g_recording.fail("Capture could not start."); media_stop(); return false; } g_auto_recording_active = true; g_auto_state = AutoState::AutoRecording; g_recording_game_pid = g_effective_game_pid; @@ -1070,25 +1061,12 @@ static void auto_record_stop() if (!g_auto_recording_active || g_recording.state() == recording::RecordingState::Idle) return; - std::wstring path; - if (g_recording.stop(&path)) { - rec_clock_stop(); - if (path.empty()) log_msg("recording", "auto recording stopped: no complete output"); - else { - log_path("recording", "auto recording saved: ", path); - // Same closure as manual stop: pending bookmarks flush into the - // clip's DB row once it exists. - const std::wstring folder = - std::filesystem::path(path).parent_path().wstring(); - std::thread(catalog_clip, path, std::string("manual"), 0.0, - [folder](int64_t id) { flush_pending_bookmarks(id, folder); }) - .detach(); - } - feedback::play(feedback::Sound::RecordStop); - tray_set_recording(false); - } + finish_recording(); + feedback::play(feedback::Sound::RecordStop); + tray_set_recording(false); g_auto_recording_active = false; g_recording_game_pid = 0; + apply_pending_media(g_main_hwnd); } // Runs the game_only capture pipeline + auto-record state machine from the shared @@ -1125,6 +1103,7 @@ static void evaluate_capture_mode(HWND hwnd) g_recording_game_pid != g_effective_game_pid) { log_msg("recording", "recorded game changed; switching auto recording"); auto_record_stop(); + media_stop(); g_replay.clear(); media_start(hwnd); } // Startup grace: don't auto-start until the user foregrounds a running @@ -1242,6 +1221,10 @@ static bool capture_encoder_config_changed(const settings::Config& a, || a.extra_ffmpeg_options != b.extra_ffmpeg_options; } +static std::optional g_deferred_settings; +static recording::PendingRestart g_pending_restart; +static HWND g_opened_target = nullptr; + static void reload_settings_from_disk(HWND hwnd) { settings::Config previous = g_settings; @@ -1249,6 +1232,16 @@ static void reload_settings_from_disk(HWND hwnd) const bool capture_or_encoder_changed = capture_encoder_config_changed(previous, g_settings); const bool audio_changed = audio_config_changed(previous, g_settings); + if (g_recording.state() != recording::RecordingState::Idle && + (capture_or_encoder_changed || audio_changed || + previous.replay_buffer_enabled != g_settings.replay_buffer_enabled || + previous.recording_enabled != g_settings.recording_enabled)) { + g_deferred_settings = g_settings; + g_settings = previous; + g_pending_restart.request(true); + return; + } + g_deferred_settings.reset(); if (previous.logging_enabled != g_settings.logging_enabled) logging::set_enabled(g_settings.logging_enabled); @@ -1273,37 +1266,13 @@ static void reload_settings_from_disk(HWND hwnd) : "automatic update checks disabled"); } - // Component toggles gate commands/menu immediately, but the media pipeline - // shape (capture/encoders started or skipped) is decided at media_start. - if (previous.replay_buffer_enabled != g_settings.replay_buffer_enabled || - previous.recording_enabled != g_settings.recording_enabled) { - log_msg("settings", "component toggles saved: restart Monolith to fully apply"); - } - - if (!capture_or_encoder_changed && !audio_changed) - return; - - if (g_recording.state() != recording::RecordingState::Idle) { - log_msg("settings", "capture/audio changes deferred: manual recording is active"); - return; - } - - if (capture_or_encoder_changed) { - log_msg("settings", "capture/encoder settings changed: restarting capture pipeline"); - media_stop(); - g_replay.clear(); - media_start(hwnd); - return; - } - - if (audio_changed) { - log_msg("settings", "audio routing changed: restarting audio pipeline"); - stop_audio_system(); - g_replay.clear(); - start_audio_system(); - poll_active_game(); - publish_runtime_status(); - } + g_pending_restart.request(capture_or_encoder_changed || audio_changed || + previous.replay_buffer_enabled != g_settings.replay_buffer_enabled || + previous.recording_enabled != g_settings.recording_enabled); + if (!g_pending_restart.take(g_recording.state() != recording::RecordingState::Idle)) return; + media_stop(); + g_replay.clear(); + media_start(hwnd); } @@ -1539,7 +1508,8 @@ static void push_audio_to_routes(const std::vector& routes, g_audio_encoders[r.track - 1].push_pcm( out_data, out_bytes, static_cast(p.sample_rate), static_cast(p.channels), - static_cast(p.bit_depth), p.is_float); + static_cast(p.bit_depth), p.is_float, + recording::capture_time_us(p.timestamp_qpc, g_audio_origin_100ns.load())); } } } @@ -2222,6 +2192,10 @@ static void media_start(HWND hwnd) apply_runtime_settings(); + if (g_settings.active_game.detection_enabled) { + SetTimer(hwnd, kActiveGameTimerId, kActiveGamePollMs, nullptr); + install_fg_hook(); + } // Do not run WGC/pacer/audio when no video output is active. Keep this // before monitor enumeration and encoder probing, which can be relatively // expensive and should not happen for replay-off idle startup. @@ -2542,6 +2516,7 @@ static void media_start(HWND hwnd) if (target) { options.target_window = target; + g_opened_target = target; log_msg("capture", "game_only: capturing detected game window"); } else { if (g_settings.capture_mode == "game_only") @@ -2577,19 +2552,13 @@ static void media_start(HWND hwnd) static void media_stop() { + g_opened_target = nullptr; // Drain capture before stopping the pacer and closing its encoder. g_video.stop(); pacer_stop(); stop_audio_system(); g_video_enc.close(); // flushes + frees encoder - if (g_recording.state() != recording::RecordingState::Idle) { - std::wstring path; - g_recording.stop(&path); - if (!path.empty()) log_path("recording", "recording saved: ", path); - } - // Stop the bookmark clock and discard pending entries when no clip will be cataloged. - rec_clock_stop(); - clear_pending_bookmarks(); + finish_recording(); g_video_enc_open_attempted.store(false, std::memory_order_release); { std::lock_guard lk(g_status_mutex); @@ -2599,6 +2568,12 @@ static void media_stop() log_msg("app", "capture + audio + encoding stopped"); } +static void apply_pending_media(HWND hwnd) { + if (!g_pending_restart.take(g_recording.state() != recording::RecordingState::Idle)) return; + if (g_deferred_settings) { g_settings = *g_deferred_settings; g_deferred_settings.reset(); } + media_stop(); g_replay.clear(); media_start(hwnd); +} + static NOTIFYICONDATAW g_nid; static HICON g_icon_base = nullptr; @@ -3096,6 +3071,7 @@ static void dispatch(Cmd cmd, HWND hwnd) break; } case CMD_RECORDING_START: + if (publication_blocks_start()) { log_msg("recording", "recording publication still pending"); break; } if (!g_recording_enabled.load(std::memory_order_relaxed)) { log_msg("recording", "recording_start ignored: recording disabled in settings"); break; @@ -3106,8 +3082,8 @@ static void dispatch(Cmd cmd, HWND hwnd) } if (g_recording.start(g_recordings_dir, g_recording_container)) { g_auto_recording_active = false; - if (!g_video.running()) - media_start(hwnd); + if (!g_video.running()) media_start(hwnd); + if (!g_video.running()) { g_recording.fail("Capture could not start."); media_stop(); break; } clear_pending_bookmarks(); rec_clock_start(); log_path("recording", "recording started: ", g_recording.current_path()); @@ -3121,19 +3097,7 @@ static void dispatch(Cmd cmd, HWND hwnd) } break; case CMD_RECORDING_STOP: { - std::wstring path; - if (g_recording.stop(&path)) { - rec_clock_stop(); - if (path.empty()) log_msg("recording", "recording stopped: no complete output"); - else { - log_path("recording", "recording saved: ", path); - // Catalog on a worker; capture the folder for the pending bookmark flush. - const std::wstring folder = - std::filesystem::path(path).parent_path().wstring(); - std::thread(catalog_clip, path, std::string("manual"), 0.0, - [folder](int64_t id) { flush_pending_bookmarks(id, folder); }) - .detach(); - } + if (finish_recording()) { feedback::play(feedback::Sound::RecordStop); tray_set_recording(false); if (!g_replay_enabled.load(std::memory_order_relaxed) && g_video.running()) @@ -3196,7 +3160,10 @@ static LRESULT CALLBACK wnd_proc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) g_replay_enabled.load(std::memory_order_relaxed), g_recording_enabled.load(std::memory_order_relaxed), g_clip_generation.load(std::memory_order_relaxed), - MONOLITH_VERSION_STRING, // engine component version (Settings) + MONOLITH_VERSION_STRING, + g_video.running(), + g_replay_enabled.load() && g_video.running() && g_video_enc.is_open(), + publication_error().empty() ? g_recording.error() : publication_error(), }; }, handle_clip_mutation, [](const std::string& exe, uint32_t /*pid*/) { @@ -3219,7 +3186,14 @@ static LRESULT CALLBACK wnd_proc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) case WM_TIMER: if (wp == kActiveGameTimerId) { + retry_publications(); + apply_pending_media(hwnd); poll_active_game(); + if (g_recording.state() == recording::RecordingState::Idle && + g_settings.capture_mode == "game_only" && g_video.running() && + recording::target_changed(g_opened_target, g_capture_target_hwnd.load())) { + media_stop(); g_replay.clear(); media_start(hwnd); + } evaluate_capture_mode(hwnd); return 0; } @@ -3232,7 +3206,14 @@ static LRESULT CALLBACK wnd_proc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) DWORD now_ms = GetTickCount(); if ((now_ms - g_last_fast_scan_ms) >= kFastScanMinGapMs) { g_last_fast_scan_ms = now_ms; + retry_publications(); + apply_pending_media(hwnd); poll_active_game(); + if (g_recording.state() == recording::RecordingState::Idle && + g_settings.capture_mode == "game_only" && g_video.running() && + recording::target_changed(g_opened_target, g_capture_target_hwnd.load())) { + media_stop(); g_replay.clear(); media_start(hwnd); + } evaluate_capture_mode(hwnd); } return 0; @@ -3244,8 +3225,10 @@ static LRESULT CALLBACK wnd_proc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) uninstall_fg_hook(); updater::shutdown(); ipc::stop(); - gamelist::shutdown(); media_stop(); + g_replay.wait_for_saves(); + g_catalog_worker.close(); + gamelist::shutdown(); hotkeys_unregister(hwnd); tray_remove(); if (g_icon_rec) { DestroyIcon(g_icon_rec); g_icon_rec = nullptr; } @@ -3266,6 +3249,7 @@ static LRESULT CALLBACK wnd_proc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) case WM_COMMAND: dispatch(static_cast(LOWORD(wp)), hwnd); + if (IsWindow(hwnd)) apply_pending_media(hwnd); return 0; case WM_SETTINGS_RELOAD: diff --git a/libs/disk-segments/disk_segments.cpp b/libs/disk-segments/disk_segments.cpp index bd19148..0a45d37 100644 --- a/libs/disk-segments/disk_segments.cpp +++ b/libs/disk-segments/disk_segments.cpp @@ -198,6 +198,10 @@ struct DiskSegmentBuffer::Impl { }; DiskSegmentBuffer::DiskSegmentBuffer() : impl_(new Impl) {} DiskSegmentBuffer::~DiskSegmentBuffer() { delete impl_; } +void DiskSegmentBuffer::wait_for_saves() { + std::lock_guard lifecycle(impl_->lifecycle); + if (impl_->save_thread.joinable()) impl_->save_thread.join(); +} void DiskSegmentBuffer::configure(Config const& cfg) { std::lock_guard lk(impl_->mutex); impl_->reconfigure = impl_->reconfigure || cfg.container != impl_->cfg.container || cfg.segment_dir != impl_->cfg.segment_dir; diff --git a/libs/disk-segments/disk_segments.h b/libs/disk-segments/disk_segments.h index 4f4bbd0..8aaf1b0 100644 --- a/libs/disk-segments/disk_segments.h +++ b/libs/disk-segments/disk_segments.h @@ -15,6 +15,7 @@ class DiskSegmentBuffer { public: DiskSegmentBuffer(); ~DiskSegmentBuffer(); + void wait_for_saves(); DiskSegmentBuffer(const DiskSegmentBuffer&) = delete; DiskSegmentBuffer& operator=(const DiskSegmentBuffer&) = delete; diff --git a/libs/ipc/ipc_server.cpp b/libs/ipc/ipc_server.cpp index 537cb0b..d8c4bd3 100644 --- a/libs/ipc/ipc_server.cpp +++ b/libs/ipc/ipc_server.cpp @@ -110,14 +110,15 @@ void handle_client(SOCKET client) std::string buf; char tmp[4096]; auto partial_started = std::chrono::steady_clock::now(); + bool received_request = false; while (g_running) { - if (!buf.empty() && std::chrono::steady_clock::now() - partial_started >= + if ((!received_request || !buf.empty()) && std::chrono::steady_clock::now() - partial_started >= detail::kPartialRequestTimeout) return; const int ready = wait_socket(client, false); if (ready < 0) return; if (ready == 0) continue; - if (!buf.empty() && std::chrono::steady_clock::now() - partial_started >= + if ((!received_request || !buf.empty()) && std::chrono::steady_clock::now() - partial_started >= detail::kPartialRequestTimeout) return; const int n = recv(client, tmp, static_cast(sizeof(tmp)), 0); if (n == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK) continue; @@ -135,6 +136,7 @@ void handle_client(SOCKET client) if (!line.empty() && line.back() == '\r') line.pop_back(); if (line.empty()) continue; + received_request = true; int req_id = -1; std::string response; @@ -171,6 +173,9 @@ void handle_client(SOCKET client) {"recording_enabled", st.recording_enabled}, {"clip_generation", st.clip_generation}, {"version", st.version}, + {"capture_running", st.capture_running}, + {"replay_running", st.replay_running}, + {"recording_error", st.recording_error}, }); } else if (method == "reload_settings") { PostMessage(g_hwnd, kMsgSettingsReload, 0, 0); @@ -221,7 +226,9 @@ void handle_client(SOCKET client) method == "clip_set_title" || method == "clip_regen_thumb" || method == "clip_delete" || - method == "clip_trim") { + method == "clip_trim" || method == "clip_add_bookmark" || + method == "clip_update_bookmark" || method == "clip_delete_bookmark" || + method == "clip_capture_thumb" || method == "clip_set_duration") { if (!g_mutation_fn) { response = make_error(req_id, -32601, "Mutations unavailable"); } else { @@ -237,6 +244,15 @@ void handle_client(SOCKET client) m.method = method; m.source = get_or("source", std::string("replay")); m.id = get_or("id", static_cast(0)); + m.catalog_uid = get_or("catalog_uid", std::string()); + m.clip_uid = get_or("clip_uid", std::string()); + m.media_revision = get_or("media_revision", int64_t{-1}); + m.seq = get_or("seq", 0); + m.time_seconds = get_or("time_seconds", 0.0); + m.label = get_or("label", std::string()); + m.color = get_or("color", std::string()); + m.upload_token = get_or("upload_token", std::string()); + m.duration = get_or("duration", 0.0); m.tag = get_or("tag", std::string()); m.favorite = get_or("favorite", false); m.new_name = get_or("new_name", std::string()); diff --git a/libs/ipc/ipc_server.h b/libs/ipc/ipc_server.h index 46d33fc..89e1922 100644 --- a/libs/ipc/ipc_server.h +++ b/libs/ipc/ipc_server.h @@ -15,6 +15,9 @@ struct RecordingState { uint64_t clip_generation = 0; // Engine and interface component versions are independent. std::string version; + bool capture_running = false; + bool replay_running = false; + std::string recording_error = {}; }; // Mutation source selects clips.db or recs.db. Callbacks run on IPC threads. @@ -22,6 +25,11 @@ struct ClipMutation { std::string method; std::string source; // "replay" | "manual" int64_t id = 0; + std::string catalog_uid, clip_uid; + int64_t media_revision = -1; + int seq = 0; + double time_seconds = 0, duration = 0; + std::string label, color, upload_token; std::string tag; // add/remove_hashtag bool favorite = false; // set_favorite std::string new_name; // clip_rename (stem, no extension) @@ -44,7 +52,7 @@ using UpdateCloseUiFn = std::function; // Server limits: 16 clients, 64 KiB lines, JSON depth 64 and 30 s I/O deadlines. // Callbacks can run concurrently and must not call start/stop. stop interrupts -// socket I/O and waits for callbacks; idle clients have no timeout. +// socket I/O and waits for callbacks; silent clients expire before their first request. void start(HWND hwnd, std::function status_fn, ClipMutationFn mutation_fn = nullptr, diff --git a/libs/recording/recording.cpp b/libs/recording/recording.cpp index 51efb73..8c480a3 100644 --- a/libs/recording/recording.cpp +++ b/libs/recording/recording.cpp @@ -300,8 +300,14 @@ RecordingState ManualRecorder::state() const void ManualRecorder::fail(std::string error) { - { std::lock_guard lk(impl_->error_mutex); impl_->error = std::move(error); } - impl_->state = RecordingState::Failed; + auto state = impl_->state.load(); + while (state != RecordingState::Idle) { + if (impl_->state.compare_exchange_weak(state, RecordingState::Failed)) { + std::lock_guard lk(impl_->error_mutex); + impl_->error = std::move(error); + return; + } + } } std::string ManualRecorder::error() const { std::lock_guard lk(impl_->error_mutex); return impl_->error; diff --git a/libs/replay-buffer/replay_buffer.cpp b/libs/replay-buffer/replay_buffer.cpp index 0e09c2a..d1d313d 100644 --- a/libs/replay-buffer/replay_buffer.cpp +++ b/libs/replay-buffer/replay_buffer.cpp @@ -53,6 +53,13 @@ struct ReplayBuffer::Impl : detail::PacketRing { ReplayBuffer::ReplayBuffer() : impl_(new Impl()) {} +void ReplayBuffer::wait_for_saves() { + if (impl_->save_thread.joinable()) impl_->save_thread.join(); + disk_segments::DiskSegmentBuffer* disk = nullptr; + { std::lock_guard lock(impl_->mutex); disk = impl_->disk.get(); } + if (disk) disk->wait_for_saves(); +} + ReplayBuffer::~ReplayBuffer() { if (impl_->save_thread.joinable()) diff --git a/libs/replay-buffer/replay_buffer.h b/libs/replay-buffer/replay_buffer.h index 3decfab..8d15b05 100644 --- a/libs/replay-buffer/replay_buffer.h +++ b/libs/replay-buffer/replay_buffer.h @@ -27,6 +27,7 @@ class ReplayBuffer { public: ReplayBuffer(); ~ReplayBuffer(); + void wait_for_saves(); ReplayBuffer(const ReplayBuffer&) = delete; ReplayBuffer& operator=(const ReplayBuffer&) = delete; diff --git a/tests/phase1/ipc_server_test.cpp b/tests/phase1/ipc_server_test.cpp index 8410fe5..bb12bd4 100644 --- a/tests/phase1/ipc_server_test.cpp +++ b/tests/phase1/ipc_server_test.cpp @@ -68,10 +68,27 @@ int main() { CHECK(!ipc::send_response(pair[0], "disconnected\n")); ipc::g_running = false; closesocket(pair[0]); - ipc::start(nullptr, [] { return ipc::RecordingState{false, false, true, true, 0, "test"}; }); + ipc::start(nullptr, [] { return ipc::RecordingState{false, false, true, true, 0, "test", true, true, "disk failure"}; }, + [](const ipc::ClipMutation& m) { + CHECK(m.catalog_uid == "catalog" && m.clip_uid == "clip"); + CHECK(m.media_revision == 7 && m.id == 1); + if (m.method == "clip_set_duration") CHECK(m.duration == 5.0); + if (m.method == "clip_capture_thumb") CHECK(m.upload_token == std::string(32, 'a')); + if (m.method == "clip_add_bookmark") CHECK(m.time_seconds == 1.5 && m.label == "marker"); + if (m.method == "clip_update_bookmark" || m.method == "clip_delete_bookmark") CHECK(m.seq == 3); + return std::string{}; + }); CHECK(ipc::g_running); SOCKET persistent = connect_client(); CHECK(status(persistent).find("result") != std::string::npos); + CHECK(status(persistent).find("disk failure") != std::string::npos); + for (const char* method : {"clip_trim", "clip_add_bookmark", "clip_update_bookmark", "clip_delete_bookmark", "clip_capture_thumb", "clip_set_duration"}) { + const auto request = nlohmann::json{{"id",2},{"method",method},{"params",{ + {"source","manual"},{"id",1},{"catalog_uid","catalog"},{"clip_uid","clip"}, + {"duration",5.0},{"media_revision",7},{"seq",3},{"time_seconds",1.5},{"label","marker"},{"upload_token",std::string(32,'a')}}}}; + write_bytes(persistent, request.dump()+"\n"); + CHECK(read_line(persistent).find("result") != std::string::npos); + } std::this_thread::sleep_for(6s); // longer than Stream Deck's five-second poll CHECK(status(persistent).find("result") != std::string::npos); write_bytes(persistent, "not json\n{\"id\":2,\"method\":\"unknown\"}\r\n"); @@ -103,9 +120,11 @@ int main() { for (SOCKET s : clients) closesocket(s); std::this_thread::sleep_for(300ms); + SOCKET silent = connect_client(); SOCKET slow = connect_client(); write_bytes(slow, "{"); std::this_thread::sleep_for(16s); write_bytes(slow, " "); // must not reset first-byte deadline CHECK(read_line(slow, 17s).empty()); closesocket(slow); + CHECK(read_line(silent).empty()); closesocket(silent); CHECK(status(persistent).find("result") != std::string::npos); // >30s idle survives closesocket(persistent); std::this_thread::sleep_for(400ms); From 8b136a7b0124a8b29460fefe206741b6c137b8ab Mon Sep 17 00:00:00 2001 From: fraa2a Date: Fri, 9 Oct 2026 16:54:44 +0200 Subject: [PATCH 12/14] docs: record verified audit integration and remaining runtime work --- docs/DECISIONS.md | 6 ++++++ docs/audit/2026-10-09-fixes.md | 23 +++++++++++++++++------ docs/handover/ACTIVE_HANDOVER.md | 17 +++++++++-------- 3 files changed, 32 insertions(+), 14 deletions(-) diff --git a/docs/DECISIONS.md b/docs/DECISIONS.md index 2554b0f..167be5e 100644 --- a/docs/DECISIONS.md +++ b/docs/DECISIONS.md @@ -353,3 +353,9 @@ Retain legacy ZIP signatures and field compatibility. Add a separate Ed25519 sig Sync a stable updater recovery copy outside the replacement plan before journaling. The engine detects pending recovery and launches that entry. Retain actual engine process handles, resolve executable path aliases consistently, and require version readiness from a live restarted child. Serialize cancellation against Applying and order snapshots/events using monotonic revisions. Old clients accept the compatible manifest, but their first upgrade still runs old transaction code. New recovery cannot fix an interruption before the stable entry has been installed; reinstall remains the migration fallback. Clean Windows installation and power-loss tests remain release requirements. + +### Audit continuation: native mutation and publication integration + +The recorder now verifies catalog/clip identity while holding the catalog mutation lock; trim, bookmark edits and captured thumbnails also require the current media revision. Trim journals the original media backup and updates duration, revision and bookmarks in one SQLite transaction. A prepared operation restores the original on recovery; a committed operation cleans its workspace. Recovery does not imply filesystem/SQLite atomicity or certified power-loss durability. + +Manual recording publication owns the media and a bounded session bookmark batch until catalog/bookmark writes complete. Failed publication retains its finalization state for retry and gates new recording starts. Recovery sidecars are attached by reconciliation; live markers before finalization are not crash-durable. Captured thumbnails use a validated 32-hex token under the fixed local `Monolith/thumb-upload` root and are copied into the catalog thumbnail folder by the engine. Rust remains a read-only catalog consumer. diff --git a/docs/audit/2026-10-09-fixes.md b/docs/audit/2026-10-09-fixes.md index df1c9f1..d56e56e 100644 --- a/docs/audit/2026-10-09-fixes.md +++ b/docs/audit/2026-10-09-fixes.md @@ -2,22 +2,22 @@ Baseline: `2e8c4ec1616215344b968a5f09a004cf9df6d494`. PR: https://github.com/fraa2a/Monolith/pull/8. -This is the implementation record for the user-approved audit. Each finding has a concrete correction or an explicitly bounded mitigation. Final verification is recorded in the PR and active handover. Portable tests and browser fixtures do not certify Windows hardware, WebView2 playback, clean installation or power-loss durability. +This is the implementation record for the user-approved audit. The table records corrections, bounded mitigations and pending work; it is not a claim that all findings are closed. Final verification is recorded in the PR and active handover. Portable tests and browser fixtures do not certify Windows hardware, WebView2 playback, clean installation or power-loss durability. | Finding | Implementation and limit | | --- | --- | | M01 | Recording pipeline initialization no longer depends on replay preferences; establish session ownership before starting producers. | -| M02 | Shared QPC capture epoch for audio and video. Long-session hardware drift remains a runtime check. | +| M02 | Direct WASAPI routes now pass capture timestamps relative to the video pacer origin. Audio settings restart the full pipeline. Mixed-track startup offset and long-session hardware drift remain runtime checks. | | M03 | Capture target changes restart WGC; Closed callbacks invalidate capture without retaining a destroyed owner. | | M04 | Retain desired settings/targets during recording and apply them after completion. | -| M05 | Bounded owned encoded-write and lifecycle workers; pause/stop avoid blocked writer locks on the tray. Drain replay callbacks and catalog tasks before teardown. Hardware latency measurements remain pending. | -| M06 | Recover audio invalidation/default endpoint changes. Optional tracks recovered after mux-header creation are deferred to the next session. | +| M05 | Catalog publication and reconciliation use one bounded owned worker; replay saves and catalog jobs drain before teardown. Encoded writes and lifecycle operations still run synchronously in the recorder. Full lifecycle/write worker integration remains pending. | +| M06 | Pending: automatic recovery after device invalidation/default endpoint changes is not integrated. Do not treat pipeline restart on settings changes as device recovery. | | M07 | Owned disk-session locks; reclaim abandoned recognizable segments only, preserving foreign files. | | M08 | Expose writer failure in operational status. Preserve valid finalized partial media while reporting failure. Retained finalization blocks a new session until retry succeeds. | | S01 | Validate trim root containment and file identity before replacement. | | S02 | Serialize trim under catalog mutation locking with operation-specific temporary files. | | S03 | Recoverable trim journal covers media, metadata and bookmark retiming. This is recovery, not instantaneous filesystem/SQLite atomicity. | -| S04 | Session-owned bounded bookmark batches and recovery sidecars, including failed finalization/shutdown. Ownership excludes destructive edits during publication. | +| S04 | Session-owned bounded batches are transferred to publication before another recording may start. Finalization writes recovery sidecars, including for failed media; publication retries retain memory/ownership and reconciliation restores completed sidecars. Abrupt process loss before the finalization sidecar is written can still lose live markers. | | S05 | Persistent catalog/clip membership UIDs; ambiguous legacy entries remain unresolved until explicitly re-added, avoiding reused-ID attachment. | | S06 | Preserve catalog rows when enumeration/access fails. | | S07 | Reconciliation excludes active, owned and temporary media. | @@ -49,7 +49,7 @@ This is the implementation record for the user-approved audit. Each finding has | Q01 | Bounded asynchronous runtime-rotated logger, drained on shutdown; preserve actual error text when file output fails. | | Q02 | Bounded custom media protocol checks current canonical roots per request; remove accumulating asset scopes and obsolete protocol feature. Retry transient thumbnail saturation. Windows range playback needs a smoke test. | | Q03 | Direct compact membership lookup instead of hydrating every collection. | -| Q04 | Extract focused worker, lifecycle, bookmark, ownership and request-pool responsibilities. This is not a complete rewrite of the recorder entrypoint. | +| Q04 | Focused catalog worker, bookmark, finalization, ownership and request-pool helpers are integrated. Full recorder lifecycle extraction is deferred. | | Q05 | Current architecture, decisions, test guidance and active handover; historical handover entries remain historical. | ## Verification commands @@ -70,3 +70,14 @@ git diff --check Both frontends run TypeScript and Vite checks. Chromium executes the desktop layout/interaction and audit fixtures. Stream Deck uses its production build and real socket tests. PowerShell produces a signed release fixture consumed by Rust with a test key. Windows CI additionally exercises real process exit, running-image replacement, recovery launch and native compilation. Before release, execute real WGC target switching, audio/device recovery, long-session synchronization, slow-disk shutdown, WebView2 range/multitrack playback, close/save failure handling and a clean-VM install/update smoke test. Journal recovery does not establish certified power-loss durability. + +## Local continuation verification + +Recovered commits `811c54e`, `2dc21d0`, `1b076f0` and `a249ca3` were cherry-picked instead of rewritten. Recovered storage/media edits were reviewed, completed and tested on `fix/audit-errors`. + +- Portable native: phase1 7/7, phase2 3/3, storage 1/1 and logging 1/1. Storage coverage includes stale identity/revision, owned-media rejection, trim bookmark retiming, injected metadata failure rollback, interrupted-trim startup recovery, symlink rejection, bookmark sidecar recovery and captured-thumbnail import. Trim codecs are stubbed in the storage suite; production codecs/muxers run in phase2. +- Rust: 28 passed with catalogs; 23 passed without catalogs. Two fixture/helper tests are ignored by default; the short-lived child helper is explicitly exercised by its parent test. The signed PowerShell fixture test was not run locally. +- Windows-target Rust updater modules and tests: `cargo check --locked --tests --no-default-features --target x86_64-pc-windows-msvc --manifest-path tests/rust/Cargo.toml` passes. This is cross-compilation checking, not Windows execution or a full Tauri/native Windows build. +- Both frontends: TypeScript checking and Vite production builds pass. Desktop layout/interaction suite and audit fixture pass after correcting the timeline fixture to use a manual-recording clip. +- Stream Deck: TypeScript build and 2 socket tests pass. Updater state ordering: 2 tests pass. Repository text and whitespace checks pass. +- Full native Windows recorder/Tauri build and hardware smoke tests remain pending. No new GitHub CI results are claimed for these local commits. Remote publication was blocked by automatic approval review; the existing PR remains at its earlier checkpoint. diff --git a/docs/handover/ACTIVE_HANDOVER.md b/docs/handover/ACTIVE_HANDOVER.md index 62836a1..de5397a 100644 --- a/docs/handover/ACTIVE_HANDOVER.md +++ b/docs/handover/ACTIVE_HANDOVER.md @@ -2,14 +2,15 @@ Updated: 2026-10-09 -## Current checkpoint: audit correction PR #8 in progress - -- User authorized the complete 2026-10-09 audit corrections in one PR: https://github.com/fraa2a/Monolith/pull/8. Branch `fix/audit-errors`, baseline `2e8c4ec1616215344b968a5f09a004cf9df6d494`. No merge or release is requested. -- Remote checkpoint `3b77da296507f6f68b0888efeb9da9f3158b8d0a` preserves initial engine helpers, host/UI/updater and logger changes. Core CI passed on that checkpoint. Windows CI exposed asymmetric process-path normalization and obsolete Tauri protocol-asset configuration; followups are being integrated. -- Local worktrees were reset twice by the execution environment before final integration was published. Recover from the remote branch; commit and push each subsequent correction promptly. Do not infer final verification from tests of an earlier local tree. -- The 45-finding implementation scope and runtime limits are in `docs/audit/2026-10-09-fixes.md`. Decisions ADR-0022/0023 describe changed contracts. Engine 1.6.3, UI 1.5.1, updater 1.0.3, Stream Deck 1.4.1. -- Final native mutation routing, storage journal and recording lifecycle integration are pending reconstruction and fresh checks at this checkpoint. Keep PR draft until final review and verification are assessed. -- Actual Windows capture/audio hardware, WebView2 media behavior, power loss and clean installation remain release checks. Historical entries below do not override this checkpoint or the user's current authorization. +## Current checkpoint: audit correction PR #8, local integration + +- User requested direct continuation without subagents and only essential remaining fixes/commits. No subagents were used in this continuation. +- Branch `fix/audit-errors` retains remote checkpoint `3b77da2`. Recovered engine/UI/host/updater commits were cherry-picked. Local version/documentation commits were preserved. +- Integrated recorder auto-start with replay disabled, deferred settings/target restarts, timestamped direct audio, operational IPC status, session bookmark publication/retry and shutdown drains. Storage now validates identities/revisions, serializes recoverable trims and restores bookmark sidecars. Added the missing `clip_capture_thumb` engine route and removed obsolete Tauri asset-protocol configuration. +- Native suites, Rust suites, Windows-target updater check, both frontend builds, browser fixtures, Stream Deck and updater ordering checks pass locally. Exact scope/limits are in `docs/audit/2026-10-09-fixes.md`. +- M05 full asynchronous recording writes/lifecycle and M06 automatic audio device recovery remain open. Abrupt exit before a finalization sidecar is written can still lose live bookmarks. Native Windows recorder/Tauri compilation, hardware recording/playback and clean update/install tests remain pending. +- The automatic approval reviewer rejected `git push origin fix/audit-errors`, interpreting the current authorization as local commits only. Do not bypass it. User approval for publishing is needed before updating https://github.com/fraa2a/Monolith/pull/8. No merge or release was requested. +- Engine 1.6.3, UI 1.5.1, updater 1.0.3, Stream Deck 1.4.1. Historical entries below do not override this checkpoint. ## Current checkpoint: screenshot-based desktop UI redesign From 2fb952eed9398ef042c162d2791cbb956d899494 Mon Sep 17 00:00:00 2001 From: fraa2a Date: Mon, 19 Oct 2026 01:07:19 +0200 Subject: [PATCH 13/14] fix(recorder): queue media writes and recover audio sources --- app/recorder/src/main.cpp | 355 +++++++++++++----- docs/DECISIONS.md | 12 + docs/audit/2026-10-09-fixes.md | 14 +- docs/handover/ACTIVE_HANDOVER.md | 18 +- .../plans/2026-10-09-audit-errors.md | 4 + libs/audio/audio.cpp | 7 +- libs/audio/source_recovery.h | 16 + libs/recording/packet_writer.h | 39 ++ tests/phase1/CMakeLists.txt | 9 + tests/phase1/packet_writer_test.cpp | 37 ++ tests/phase1/source_recovery_test.cpp | 23 ++ tests/phase2/media_test.cpp | 31 ++ 12 files changed, 449 insertions(+), 116 deletions(-) create mode 100644 libs/audio/source_recovery.h create mode 100644 libs/recording/packet_writer.h create mode 100644 tests/phase1/packet_writer_test.cpp create mode 100644 tests/phase1/source_recovery_test.cpp diff --git a/app/recorder/src/main.cpp b/app/recorder/src/main.cpp index a221934..fc7db24 100644 --- a/app/recorder/src/main.cpp +++ b/app/recorder/src/main.cpp @@ -18,6 +18,7 @@ #include #include