diff --git a/.automator/decisions.json b/.automator/decisions.json index 7d6ea4f..60cfda7 100644 --- a/.automator/decisions.json +++ b/.automator/decisions.json @@ -7,14 +7,5 @@ "key": "1", "label": "Keep monitoring specta", "resolution": "" - }, - "DW-85": { - "answered_at": "2026-06-13", - "bundle_name": "", - "effect": "keep-open", - "intent": "Keep tracking until a cross-platform timeout + worker-budget design (covering the Windows named-pipe no-timeout constraint) is decided.", - "key": "1", - "label": "Defer until cross-platform design agreed", - "resolution": "" } } \ No newline at end of file diff --git a/.automator/policy.toml b/.automator/policy.toml index 5b085f6..4a03180 100644 --- a/.automator/policy.toml +++ b/.automator/policy.toml @@ -45,3 +45,6 @@ auto = "per-epic" # never | per-epic | run-end (auto-triggered swe max_bundles = 5 # bundles executed per sweep; triage excess is truncated max_triage_attempts = 2 # triage validation retries before escalating repeat = true + +[scm] +isolation = "worktree" diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml new file mode 100644 index 0000000..0a09b17 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.yml @@ -0,0 +1,61 @@ +name: Bug report +description: Report something that isn't working as expected in Notey. +title: "[Bug]: " +labels: ["bug"] +body: + - type: markdown + attributes: + value: | + Thanks for taking the time to file a bug report! Please fill out the + sections below so we can reproduce and fix the issue. + - type: textarea + id: what-happened + attributes: + label: What happened? + description: A clear and concise description of the bug. + placeholder: When I do X, Y happens instead of Z. + validations: + required: true + - type: textarea + id: steps + attributes: + label: Steps to reproduce + description: How can we reproduce the behavior? + placeholder: | + 1. Open Notey with the global hotkey + 2. Press Ctrl+P and run '...' + 3. See the error + validations: + required: true + - type: textarea + id: expected + attributes: + label: Expected behavior + description: What did you expect to happen? + validations: + required: true + - type: dropdown + id: os + attributes: + label: Operating system + options: + - Linux + - macOS + - Windows + validations: + required: true + - type: input + id: version + attributes: + label: Notey version + description: See the About/Settings, or the release you installed. + placeholder: 0.1.0 + validations: + required: true + - type: textarea + id: logs + attributes: + label: Logs or screenshots + description: Paste any relevant logs or attach screenshots. (Logs live in the platform state/log directory.) + validations: + required: false diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml new file mode 100644 index 0000000..319bd23 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/config.yml @@ -0,0 +1,8 @@ +blank_issues_enabled: false +contact_links: + - name: Security vulnerability + url: https://github.com/pbean/notey/security/advisories/new + about: Please report security issues privately — do not open a public issue. See SECURITY.md. + - name: Question or discussion + url: https://github.com/pbean/notey/discussions + about: Ask questions and discuss ideas with the community. diff --git a/.github/ISSUE_TEMPLATE/feature_request.yml b/.github/ISSUE_TEMPLATE/feature_request.yml new file mode 100644 index 0000000..aced985 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.yml @@ -0,0 +1,31 @@ +name: Feature request +description: Suggest an idea or improvement for Notey. +title: "[Feature]: " +labels: ["enhancement"] +body: + - type: markdown + attributes: + value: | + Thanks for the suggestion! Notey aims to stay a fast, focused capture tool — + please describe the problem you're trying to solve, not just the solution. + - type: textarea + id: problem + attributes: + label: What problem does this solve? + description: What are you trying to do that Notey makes hard or impossible today? + validations: + required: true + - type: textarea + id: proposal + attributes: + label: Proposed solution + description: Describe what you'd like to happen. + validations: + required: true + - type: textarea + id: alternatives + attributes: + label: Alternatives considered + description: Any alternative approaches or workarounds you've thought about. + validations: + required: false diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md new file mode 100644 index 0000000..36b75db --- /dev/null +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -0,0 +1,28 @@ + + +## Summary + + + +## Changes + + + +- + +## Testing + + + +- [ ] `npm test` passes +- [ ] `cargo test` passes (in `src-tauri/`) +- [ ] `npm run build` is clean +- [ ] `node e2e/run.mjs` passes (if behavior is user-facing) +- [ ] Verified manually in the running app + +## Checklist + +- [ ] My changes follow the conventions of the surrounding code +- [ ] I updated `CHANGELOG.md` under **Unreleased** +- [ ] I updated relevant documentation (README/`docs/`) +- [ ] I regenerated `src/generated/bindings.ts` if I changed a Tauri command/event diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 0000000..b1e9a88 --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,97 @@ +name: Release + +# Builds and uploads Notey bundles for all five targets required by AC4 of +# story 8.6 — Windows x64, macOS x64, macOS ARM64, Linux x64, Linux ARM64 — +# to a draft GitHub Release from a release tag. +on: + push: + tags: + - 'v*' + workflow_dispatch: + inputs: + releaseTag: + description: 'Existing release tag to build, e.g. v1.2.3' + required: true + type: string + +env: + CARGO_TERM_COLOR: always + +jobs: + release: + permissions: + contents: write # required to create the GitHub Release and upload assets + strategy: + fail-fast: false # one target failing must not cancel the others + matrix: + include: + - platform: macos-latest # macOS ARM64 (Apple Silicon) + args: '--target aarch64-apple-darwin' + - platform: macos-15-intel # macOS x64 (Intel) + args: '--target x86_64-apple-darwin' + - platform: ubuntu-22.04 # Linux x64 + args: '' + - platform: ubuntu-22.04-arm # Linux ARM64 (native GitHub-hosted ARM runner) + args: '' + - platform: windows-latest # Windows x64 + args: '' + + name: ${{ matrix.platform }} ${{ matrix.args }} + runs-on: ${{ matrix.platform }} + + steps: + - name: Validate manual release tag + if: github.event_name == 'workflow_dispatch' + shell: bash + env: + RELEASE_TAG: ${{ inputs.releaseTag }} + run: | + if [[ ! "$RELEASE_TAG" =~ ^v.+ ]]; then + echo "releaseTag must match the release tag pattern v*" + exit 1 + fi + + - uses: actions/checkout@v6 + with: + ref: ${{ github.event_name == 'workflow_dispatch' && inputs.releaseTag || github.ref }} + + - name: Install system dependencies (Linux) + if: startsWith(matrix.platform, 'ubuntu-') + run: | + sudo apt-get update + sudo apt-get install -y libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf libxdo-dev + + - name: Setup Node.js + uses: actions/setup-node@v6 + with: + node-version: 22 + cache: npm + + - name: Install Rust toolchain + # Pinned nightly required by specta =2.0.0-rc.24 (see rust-toolchain.toml). + # On macOS, install both apple-darwin targets so each matrix job can + # cross-build its single architecture via the --target arg. + uses: dtolnay/rust-toolchain@master + with: + toolchain: nightly-2026-04-03 + targets: ${{ startsWith(matrix.platform, 'macos-') && 'aarch64-apple-darwin,x86_64-apple-darwin' || '' }} + + - name: Cache Cargo + uses: swatinem/rust-cache@v2 + with: + workspaces: './src-tauri -> target' + + - name: Install npm dependencies + run: npm ci + + - name: Build and release Notey + uses: tauri-apps/tauri-action@v0 + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + with: + tagName: ${{ github.event_name == 'workflow_dispatch' && inputs.releaseTag || github.ref_name }} + releaseName: Notey ${{ github.event_name == 'workflow_dispatch' && inputs.releaseTag || github.ref_name }} + releaseBody: 'See the assets below to download and install this version.' + releaseDraft: true # artifacts are unsigned (v1) — a human publishes after review + prerelease: false + args: ${{ matrix.args }} diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..67c52da --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,69 @@ +# Changelog + +All notable changes to Notey are documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [Unreleased] + +_Nothing yet._ + +## [0.1.0] - 2026-06-17 + +The first release of Notey — a fast, keyboard-driven, workspace-aware note-capture +desktop app built on Tauri 2, React 19, and Rust with a local SQLite store. + +### Added + +#### Capture & editing +- Always-on-top capture window (720×480) that launches hidden and is summoned from + the system tray or a global hotkey. +- Global capture hotkey (default `Ctrl+Shift+N`, `Cmd+Shift+N` on macOS) that + shows/focuses the window and toggles it away again. +- CodeMirror 6 editor with Markdown and plain-text formats and a per-note format + toggle. +- Debounced auto-save with a live save-status indicator (idle / saving / saved / + failed) and flush-on-dismiss. +- Multi-tab editing: open several notes at once, reorder tabs, and navigate with + `Ctrl+Tab` / `Ctrl+Shift+Tab` / `Ctrl+1…9`. +- Session persistence — open tabs, cursor, and scroll position survive restarts. + +#### Organization & discovery +- Workspaces tied to filesystem paths, with auto-detection and a status-bar + workspace selector. +- Note list panel filtered to the active workspace or "All Workspaces". +- Full-text search (SQLite FTS5 with BM25 ranking) with match snippets, scoped to a + workspace or global. +- Command palette (`Ctrl+P`) exposing every action with fuzzy search. + +#### Lifecycle & data +- Soft-delete to trash with restore and permanent-delete, plus a configurable + retention window (default 30 days) that auto-purges on startup. +- Export all notes to Markdown files or a single JSON document. + +#### CLI integration +- A standalone `notey` CLI (`add`, `list`, `search`) that talks to the running app + over a local IPC socket, with live desktop sync when notes are added. + +#### Personalization & accessibility +- Light / dark / follow-system themes applied at boot (no flash). +- Configurable font size and family, and floating / half-screen / full-screen + layout modes. +- Rebindable in-app shortcuts with conflict detection; settings persisted to + `config.toml`. +- Keyboard-first navigation throughout, focus traps in overlays, and screen-reader + announcements. + +#### Platform integration +- System tray with open/quit, opt-in auto-start on login, and first-run onboarding + (including macOS accessibility-permission guidance). +- Cross-platform builds for macOS (arm64/x64), Linux (x64/arm64), and Windows (x64). + +### Known issues +- On pure Wayland sessions without XWayland, the OS-level global capture hotkey may + be unavailable; the window remains summonable from the tray and a notice is shown. + A native Wayland global-shortcut portal is planned (see [ROADMAP.md](ROADMAP.md)). + +[Unreleased]: https://github.com/pbean/notey/compare/v0.1.0...HEAD +[0.1.0]: https://github.com/pbean/notey/releases/tag/v0.1.0 diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..9406f16 --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1,46 @@ +# Code of Conduct + +## Our pledge + +We want participation in the Notey project to be a welcoming, respectful, and +harassment-free experience for everyone, regardless of background or identity. + +## Our standards + +Examples of behavior that helps build a positive community: + +- Being kind, patient, and respectful to others. +- Welcoming differing viewpoints and giving constructive feedback gracefully. +- Focusing on what is best for the community and the project. +- Showing empathy toward other community members. + +Examples of unacceptable behavior: + +- Personal attacks, insults, or derogatory comments. +- Public or private harassment of any kind. +- Publishing others' private information without explicit permission. +- Other conduct that would reasonably be considered inappropriate in a + professional setting. + +## Our standards in practice + +This project adopts the [Contributor Covenant](https://www.contributor-covenant.org), +version 2.1, as the basis for expected behavior. The full text is available at +. + +## Scope + +This Code of Conduct applies within all project spaces — the repository, issues, +pull requests, and discussions — and in public spaces when an individual is +representing the project. + +## Enforcement + +Instances of unacceptable behavior may be reported to the project maintainer at +**pinkyd@luckytick.net**. All reports will be reviewed and investigated promptly +and fairly, and the maintainer will respect the privacy and security of the +reporter of any incident. + +Maintainers are responsible for clarifying standards and may take appropriate and +fair corrective action in response to behavior they deem inappropriate, up to and +including removing contributions or banning contributors. diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..2c2c9a8 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,111 @@ +# Contributing to Notey + +Thanks for your interest in improving Notey! This guide covers how to set up a +development environment, build and test the app, and submit changes. + +By participating you agree to abide by our [Code of Conduct](CODE_OF_CONDUCT.md). + +## Prerequisites + +- **Node.js** 20+ (CI uses 22) and **npm**. +- **Rust** — the toolchain is pinned in [`rust-toolchain.toml`](rust-toolchain.toml) + (`nightly-2026-04-03`); install [rustup](https://rustup.rs) and it will be selected + automatically. +- **Tauri system dependencies** for your OS — see the official + [Tauri prerequisites](https://tauri.app/start/prerequisites/). + +### Linux system packages + +The CI image installs these (Debian/Ubuntu names); install the equivalents for your +distribution: + +```sh +sudo apt-get install -y \ + libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev \ + patchelf libxdo-dev webkit2gtk-driver +``` + +`webkit2gtk-driver` and `tauri-driver` (`cargo install --locked tauri-driver`) are +only needed to run the end-to-end suite and the screenshot capture. + +## Running the app + +```sh +npm install # install front-end dependencies +npm run tauri dev # run with hot-reload (Vite dev server + Rust watch) +``` + +The window starts hidden; summon it with the global hotkey (`Ctrl+Shift+N`) or from +the system tray. + +## Building + +```sh +npm run build # type-check + build the front end (dist/) +npx tauri build --debug --no-bundle # debug binary at src-tauri/target/debug/notey +npx tauri build # release bundles for your platform +``` + +## Testing + +```sh +npm test # front-end unit tests (Vitest) +cargo test # Rust unit + integration tests (run in src-tauri/) +node e2e/run.mjs # end-to-end tests via tauri-driver (needs a debug build) +``` + +On a headless Linux box, wrap GUI-driven commands with `xvfb-run` and the WebKitGTK +software-rendering flags (the E2E runner sets these automatically). + +## Regenerating screenshots + +Documentation screenshots in `docs/images/` are produced from the live app: + +```sh +npx tauri build --debug --no-bundle # ensure the debug binary is current +npm run screenshots # drives the app and writes docs/images/*.png +# headless: xvfb-run -a npm run screenshots +``` + +## Type-safe IPC bindings + +Rust commands and events are exposed to TypeScript via +[tauri-specta](https://github.com/oscartbeaumont/tauri-specta). The generated file +`src/generated/bindings.ts` is committed; it is regenerated when the app builds in +debug. After changing a `#[tauri::command]` / `#[specta::specta]` signature, rebuild +so the bindings stay in sync, and commit the result. + +## Project layout + +``` +src/ React 19 + TypeScript front end, organized by feature + features// each feature owns its store, components, and API calls + components/ui/ shared UI primitives + generated/ tauri-specta TypeScript bindings (generated) +src-tauri/ Rust back end + src/commands/ Tauri IPC command handlers + src/services/ business logic + src/db/ SQLite schema + migrations (FTS5) + src/ipc/ local socket server for the CLI + src/platform/ OS abstraction (macOS / Linux / Windows) +notey-cli/ standalone `notey` CLI (talks to the app over the socket) +e2e/ tauri-driver E2E suite + screenshot capture +docs/ user-facing documentation +``` + +See [docs/architecture.md](docs/architecture.md) for a deeper overview. + +## Pull requests + +1. Fork and create a feature branch off `main`. +2. Keep changes focused; match the conventions of the surrounding code. +3. Add or update tests for behavioral changes. +4. Make sure `npm test`, `cargo test`, `npm run build`, and (where relevant) + `node e2e/run.mjs` pass. +5. Update `CHANGELOG.md` under **Unreleased** and any affected docs. +6. Open a PR describing the change and linking any related issue. + +## Reporting bugs and requesting features + +Use the [issue templates](https://github.com/pbean/notey/issues/new/choose). For +security issues, follow [SECURITY.md](SECURITY.md) instead of opening a public issue. diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..75d8b91 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026 Paul Bean + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md index 102e366..153541f 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,125 @@ -# Tauri + React + Typescript +
-This template should help get you started developing with Tauri, React and Typescript in Vite. +# Notey -## Recommended IDE Setup +**A fast, keyboard-driven, workspace-aware note-capture app for your desktop.** -- [VS Code](https://code.visualstudio.com/) + [Tauri](https://marketplace.visualstudio.com/items?itemName=tauri-apps.tauri-vscode) + [rust-analyzer](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer) +Summon it with a global hotkey, capture a thought, hit `Esc` — it's gone until you need it again. + +[![CI](https://github.com/pbean/notey/actions/workflows/ci.yml/badge.svg)](https://github.com/pbean/notey/actions/workflows/ci.yml) +[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE) +![Tauri](https://img.shields.io/badge/Tauri-2-24C8DB?logo=tauri&logoColor=white) +![React](https://img.shields.io/badge/React-19-61DAFB?logo=react&logoColor=black) +![Rust](https://img.shields.io/badge/Rust-stable-000000?logo=rust&logoColor=white) + +![Notey editor](docs/images/editor-light.png) + +
+ +## What is Notey? + +Notey is a lightweight desktop notepad built for *quick capture*. It lives in your +system tray as a small always-on-top window that you summon with a global hotkey, +type into instantly, and dismiss with `Esc`. Notes are organized by **workspace** +(typically a project directory), searchable with full-text search, and persisted +locally in SQLite — no account, no cloud, no telemetry. + +It's built with [Tauri 2](https://tauri.app), a React 19 + TypeScript front end, and a +Rust back end, so it starts fast, stays small, and runs natively on macOS, Linux, and +Windows. + +## Features + +- **Instant capture** — a global hotkey (default `Ctrl+Shift+N`) shows and focuses the + window from anywhere; `Esc` hides it again. +- **Workspaces** — group notes by project directory; filter the list and search to the + active workspace or view everything at once. +- **Full-text search** — SQLite FTS5 with BM25 ranking and match snippets. +- **Tabs** — keep several notes open at once, reorder them, and jump between them with + the keyboard. +- **Markdown or plain text** — a CodeMirror 6 editor with per-note format toggle and + auto-save (no save button, ever). +- **Command palette** — `Ctrl+P` for every action, fuzzy-searchable. +- **Trash & restore** — soft-delete with recovery and a configurable retention window. +- **Export** — dump your notes to Markdown files or a single JSON document. +- **CLI** — a `notey` command-line companion that talks to the running app over a local + socket (add, list, search) with live desktop sync. +- **Themeable** — light / dark / follow-system, adjustable font, and floating / + half-screen / full-screen layouts. +- **Accessible & keyboard-first** — full keyboard navigation, focus traps, and + screen-reader announcements. + +## Screenshots + +| Command palette | Search | Note list | +| --- | --- | --- | +| ![Command palette](docs/images/command-palette.png) | ![Search](docs/images/search.png) | ![Note list](docs/images/note-list.png) | + +| Settings | Trash | Dark theme | +| --- | --- | --- | +| ![Settings](docs/images/settings-general.png) | ![Trash](docs/images/trash.png) | ![Dark theme](docs/images/editor-dark.png) | + +## Install + +Download the latest bundle for your platform from the +[Releases page](https://github.com/pbean/notey/releases), or +[build from source](docs/installation.md). See the +[installation guide](docs/installation.md) for platform-specific notes. + +## Quick start + +1. Launch Notey — it starts hidden in the system tray. +2. Press the global hotkey (`Ctrl+Shift+N`, or `Cmd+Shift+N` on macOS) to summon it. +3. Start typing. Your note auto-saves as you go. +4. Press `Ctrl+P` to open the command palette and discover everything else. +5. Press `Esc` to dismiss the window; summon it again any time. + +New here? Read the [user guide](docs/user-guide.md) and the +[keyboard shortcuts](docs/keyboard-shortcuts.md). + +## Development + +Notey uses **npm** for the front end and **Cargo** for the Rust back end. + +```sh +# Prerequisites: Node.js 20+, Rust (stable), and the Tauri system dependencies +# for your OS — see CONTRIBUTING.md. + +npm install # install front-end dependencies +npm run tauri dev # run the app with hot-reload (Vite + Rust watch) +``` + +Other useful scripts: + +```sh +npm run build # type-check + build the front end +npm test # front-end unit tests (Vitest) +node e2e/run.mjs # end-to-end tests (tauri-driver) +npm run screenshots # regenerate docs/images/*.png from the live app +``` + +For the full contributor workflow, system dependencies, and project layout, see +[CONTRIBUTING.md](CONTRIBUTING.md). + +## Documentation + +| Guide | What's inside | +| --- | --- | +| [Installation](docs/installation.md) | Install per platform & build from source | +| [User guide](docs/user-guide.md) | Feature-by-feature walkthrough | +| [Keyboard shortcuts](docs/keyboard-shortcuts.md) | Full shortcut reference | +| [Configuration](docs/configuration.md) | `config.toml` reference | +| [CLI](docs/cli.md) | The `notey` command-line companion | +| [Architecture](docs/architecture.md) | How Notey is built | +| [Roadmap](ROADMAP.md) | What's shipped and what's next | +| [Changelog](CHANGELOG.md) | Release history | + +## Contributing + +Contributions are welcome! Please read [CONTRIBUTING.md](CONTRIBUTING.md) and our +[Code of Conduct](CODE_OF_CONDUCT.md) before opening a pull request. Security issues +should follow [SECURITY.md](SECURITY.md). + +## License + +Notey is open source under the [MIT License](LICENSE). diff --git a/ROADMAP.md b/ROADMAP.md new file mode 100644 index 0000000..d6af9e2 --- /dev/null +++ b/ROADMAP.md @@ -0,0 +1,53 @@ +# Roadmap + +This roadmap describes the direction of Notey. It is a statement of intent, not a +commitment to dates or ordering — priorities shift as the project and its users +evolve. For released changes see the [Changelog](CHANGELOG.md). + +**Legend:** ✅ Shipped · 🚧 In progress · 🔭 Planned + +## ✅ Shipped (v0.1.0) + +The 0.1.0 release delivered the core product across eight areas of work: + +- **Instant capture** — hidden-by-default capture window, global hotkey, tray, and + fast dismiss. +- **Editing** — CodeMirror 6 editor, Markdown/plain-text toggle, debounced auto-save, + multi-tab editing, and session persistence. +- **Workspaces** — path-based workspaces with detection and a status-bar selector. +- **Search & discovery** — FTS5 full-text search and a fuzzy command palette. +- **Note lifecycle** — trash, restore, retention-based auto-purge, and export to + Markdown/JSON. +- **CLI** — `notey add / list / search` over a local socket with live desktop sync. +- **Personalization & accessibility** — themes, fonts, layout modes, rebindable + shortcuts, and keyboard-first/screen-reader support. +- **Platform integration** — tray, auto-start, onboarding, and cross-platform release + builds. + +## 🚧 In progress + +- **CLI hardening** — broadening the `notey` command surface and finishing the + end-to-end live-sync coverage between the CLI and the desktop app. +- **Cross-platform polish** — routing auto-start through the platform abstraction and + shoring up Windows-specific IPC verification. + +## 🔭 Planned + +- **Native Wayland global shortcut** — a `xdg-desktop-portal` GlobalShortcuts + integration so the capture hotkey works on pure Wayland without relying on + XWayland (today's baseline fallback). +- **Richer search** — query operators and result previews building on the FTS5 + foundation. +- **Editor enhancements** — Markdown niceties (link handling, lists, and live + preview affordances) within the lightweight capture model. +- **Sync & backup** — optional mechanisms for moving notes between machines while + staying local-first by default. + +## Out of scope (for now) + +Notey is deliberately small and local-first. Accounts, mandatory cloud storage, and +heavyweight knowledge-base features are not planned — the goal is a fast capture tool, +not a second brain platform. + +Have an idea? Open a +[feature request](https://github.com/pbean/notey/issues/new/choose). diff --git a/SECURITY.md b/SECURITY.md new file mode 100644 index 0000000..a2a179b --- /dev/null +++ b/SECURITY.md @@ -0,0 +1,45 @@ +# Security Policy + +## Supported versions + +Notey is in active early development. Security fixes are applied to the latest +released version and `main`. + +| Version | Supported | +| ------- | --------- | +| 0.1.x | ✅ | +| < 0.1 | ❌ | + +## Reporting a vulnerability + +**Please do not report security vulnerabilities through public GitHub issues.** + +Instead, report privately through either of: + +- GitHub's [private vulnerability reporting](https://github.com/pbean/notey/security/advisories/new) + ("Report a vulnerability" under the Security tab), or +- Email **pinkyd@luckytick.net** with the details. + +Please include: + +- A description of the issue and its impact. +- Steps to reproduce (a proof of concept if possible). +- Affected version(s) and platform(s). + +You can expect an acknowledgement within a few days. We'll keep you updated on +progress and coordinate a disclosure timeline with you once a fix is ready. + +## Scope notes + +Notey is a **local-first desktop application**. It stores notes in a local SQLite +database and exposes a **local IPC socket** (Unix domain socket / named pipe) so the +`notey` CLI can talk to the running app. It does not run a network server and does not +transmit your notes anywhere. + +Reports of particular interest include: + +- Issues with the local IPC socket (e.g. unauthorized local access, input handling). +- Path-traversal or injection issues in workspace/path handling, search, or export. +- Anything that could lead to data loss or corruption of the notes database. + +Thank you for helping keep Notey and its users safe. diff --git a/_bmad-output/implementation-artifacts/deferred-work.md b/_bmad-output/implementation-artifacts/deferred-work.md index 5ee8141..6e079a1 100644 --- a/_bmad-output/implementation-artifacts/deferred-work.md +++ b/_bmad-output/implementation-artifacts/deferred-work.md @@ -706,7 +706,9 @@ resolution: bindingsFromConfig now applies first-binding-wins dedupe at load (re origin: code review of spec-singleflight-guard-helper.md (edge-case + blind review), 2026-06-14 location: src/lib/singleflight.ts:50 reason: The shared `singleflight` helper only clears an in-flight key in `started.finally(...)`. If the wrapped operation never settles (e.g. a Tauri IPC/dialog promise that hangs), the key stays in the `inFlight` map forever and every later same-key call coalesces onto the dead promise, so that command (createNewNote/toggleTheme/export/note-list refresh) is disabled until reload. This is a PRE-EXISTING gap inherited from the hand-rolled boolean guards it replaced (they likewise never reset on a hung promise), surfaced incidentally by this refactor — it is NOT a regression. Adding a timeout/abort to the helper is explicitly out of scope per the spec's "Never" boundary (no timers/retries in the helper), so it needs a deliberate design call: whether to add an optional abort/timeout to the helper or to push timeouts to the IPC layer (note Story 6.7 already added a 5s timeout on the CLI side). -status: open +status: done 2026-06-16 +resolution: Added `src/lib/withTimeout.ts` (IpcTimeoutError + 5s default / 60s export bound) and wrapped the Tauri `commands.*` invokes inside every singleflight-wrapped flight (create-note, toggle-theme, toggle-layout-mode, trash-active-note, note-list-refresh, export-json, export-markdown), including helper IPC reached through `flushSave()` and `loadNote()`; a hung invoke now rejects and releases its singleflight key through existing error paths. singleflight.ts left timer-free (unchanged); native dialogs left unwrapped. +decision: 2026-06-16 Timeout at the IPC layer — Add a timeout/abort wrapper around the Tauri invoke layer (mirroring the CLI's 5s timeout from Story 6.7) so wrapped operations always settle, keeping singleflight timer-free and respecting its 'Never' boundary. ### DW-91: First-feature E2E leaves orphaned marker notes if it fails mid-cycle @@ -744,4 +746,42 @@ status: open origin: local verification of epic-6 retro item-1 (E2E), 2026-06-16 location: e2e/run.mjs (cliLiveSyncTests, waitForAppSocket / realInstancePresent guard) reason: The CLI live-sync suite originally pinned a unique per-run `NOTEY_SOCKET_PATH` so the test app and CLI rendezvous on their own endpoint, isolated from any real notey instance. This relies on the env var propagating to the tauri-driver-launched app. It holds on CI's older Ubuntu `webkit2gtk-driver`, but a modern WebKitWebDriver (verified locally on `webkit2gtk-4.1 2.52.4`) **resets the launched app's environment** — stripping `NOTEY_SOCKET_PATH` and forcing `XDG_RUNTIME_DIR` back to the real session value — and `tauri-driver 2.0.6` forwards only `{binary, args}` (no env passthrough). So locally the app always binds the default `$XDG_RUNTIME_DIR/notey.sock`, diverging from the per-run path the CLI used → `notey add` failed exit-2 ("not running") and the suite was 14/16 locally while green on CI. Fixed test-only by discovering the socket the app actually bound (probe configured path + `$XDG_RUNTIME_DIR/notey.sock` for liveness) and pointing the CLI there — local now 16/16, CI unchanged (it matches the first candidate). Residual limitation: because the test app falls back to the *default* socket locally, the suite cannot isolate from a real running notey; it now detects a live pre-existing instance and skips the live-sync suite with an actionable message rather than hijacking it. Proper isolation would need either an env-passthrough in a newer tauri-driver or an app-level `--socket-path` arg routed via `tauri:options.args` (app source change; deferred). Test-harness robustness, not a product defect. +status: done 2026-06-16 +resolution: Added a permissive `--socket-path` parser to `socket_server::socket_path()` (precedence: CLI arg > `NOTEY_SOCKET_PATH` > default) with unit tests, and routed a per-run `--socket-path` through `tauri:options.args` in `e2e/run.mjs` (via `createSession(application, args)`); the live-sync suite now binds an isolated endpoint regardless of env stripping, so the `realInstancePresent` skip guard and multi-candidate socket discovery were removed. +decision: 2026-06-16 App-level --socket-path arg — Add a --socket-path CLI arg to the desktop app that overrides the socket path, and route a per-run unique path through tauri:options.args in e2e/run.mjs so each E2E run binds an isolated endpoint independent of env propagation. + +### DW-96: Native Wayland global-shortcut portal via `ashpd` (fast-follow) + +origin: bmad-auto-dev split of spec-8-6-cross-platform-verification-wayland-fallback.md, 2026-06-17 +location: src-tauri/src/platform/linux.rs (register_hotkey WaylandPortal arm); test linux_hotkey_falls_back_to_wayland_portal (#[ignore]) +severity: medium +reason: PRD (prd.md:144,323,423) and architecture.md (49,870) explicitly scope the native xdg-desktop-portal GlobalShortcuts integration as a post-v1 fast-follow gated on Tauri global-hotkey PR #162; v1's Wayland fallback is XWayland (epic-8 context "XWayland is the baseline fallback for v1"). The trait + HotkeyBackend::WaylandPortal enum already anticipate it; implementing the real ashpd D-Bus registration + activation-signal wiring needs a Wayland harness (un-CI-testable) and a new async dependency. Deferred from the 8.6 capstone to keep that story CI-verifiable. status: open + +### DW-97: Route auto-start through the `Platform` trait (autostart_enable/disable/is_enabled) + +origin: bmad-auto-dev split of spec-8-6-cross-platform-verification-wayland-fallback.md, 2026-06-17 +location: src-tauri/src/platform/{linux,macos,windows}.rs (autostart_* methods, currently todo!()) +severity: low +reason: The trait's autostart_* methods take only &self with no Tauri AppHandle, but the real mechanism (tauri-plugin-autostart via app.autolaunch()) requires the handle and already fully satisfies FR41-43 from Story 8.4 (commands/autostart.rs + lib.rs reconcile). Routing through the trait would mean reimplementing the plugin's plist/.desktop/registry logic by hand — a refactor with no functional gain and real cross-platform risk. Needs a trait-signature redesign (pass the handle, or move autostart off the path-trait) before it is worth doing. The todo!() stubs are relabeled to point here. +status: done 2026-06-17 +resolution: Redesigned the `Platform` trait's `autostart_enable/disable/is_enabled` to take `&tauri::AppHandle` (kept object-safe). Added shared `pub(crate)` `autostart_*` helpers in `platform/mod.rs` that delegate to `app.autolaunch()` (one call site, no per-OS reimplementation); each of linux/macos/windows now delegates to them instead of `todo!()`. Switched `commands/autostart.rs` (`set_autostart` incl. rollback, `get_autostart`) and the `lib.rs` startup reconcile to route through `crate::platform::current()`. No behavior/IPC/bindings change; FR41–43 preserved. Verified: cargo build, clippy -D warnings, autostart_tests + platform_tests green, no `.autolaunch()` call sites outside `platform/mod.rs`, bindings.ts unchanged. +decision: 2026-06-17 Redesign trait + route — Redesign the Platform trait's autostart_* signatures to accept the Tauri AppHandle (or move autostart off the path-trait into a dedicated abstraction), then implement autostart_enable/disable/is_enabled on each platform by delegating to tauri-plugin-autostart's autolaunch(), and switch commands/autostart.rs to call through the trait. + +### DW-98: CI release pipeline producing artifacts for all 5 targets (FR — AC4 of 8.6) + +origin: bmad-auto-dev split of spec-8-6-cross-platform-verification-wayland-fallback.md, 2026-06-17 +location: .github/workflows/ (new release.yml; ci.yml currently runs tests + a Linux debug build only) +severity: medium +reason: AC4 of story 8.6 wants build artifacts for Windows x64, macOS x64, macOS ARM64, Linux x64, Linux ARM64 (via tauri-apps/tauri-action on tag push). This is a standalone ops/infra deliverable that cannot be exercised by this session's cargo test / clippy / vitest gate (it only runs on a release tag), so adding an unverifiable workflow here would give no confidence. Belongs in its own release-engineering PR. +status: done 2026-06-17 +resolution: Added .github/workflows/release.yml — tag-push (`v*`) + workflow_dispatch trigger with explicit releaseTag input, tauri-action@v0 with a 5-entry fail-fast:false matrix (macos-latest ARM64, macos-15-intel x64, ubuntu-22.04, native ubuntu-22.04-arm, windows-latest), pinned nightly-2026-04-03 toolchain, draft GitHub Release. Validated with YAML parse; actionlint was unavailable in the review environment. + +### DW-99: User-facing notification when the global shortcut is unavailable on the compositor (FR57) + +origin: bmad-auto-dev split of spec-8-6-cross-platform-verification-wayland-fallback.md, 2026-06-17 +location: src/ (frontend toast/dialog) + src-tauri/src/lib.rs (global-shortcut setup) +severity: low +reason: FR57 / AC2 asks that the user be notified when no hotkey backend works on their compositor. Story 8.6 implements the backend detection (Platform::register_hotkey) and a clear startup warning log for the unavailable case, but the user-facing UI surface (toast/dialog + a typed event) is separable frontend work. Deferred to keep 8.6 backend-only and CI-verifiable; the backend signal it needs is in place. +status: done 2026-06-17 +resolution: 2026-06-17 (spec-dw-hotkey-unavailable-user-notification.md). The `register_hotkey` Err arm in lib.rs now records the outcome in managed `Mutex` state (new models/hotkey.rs); a thin sync command `get_hotkey_status` (commands/hotkey.rs, +ACL/perm) exposes it. Frontend `startHotkeyUnavailableNotice` pulls it at startup and raises a persistent, click-dismissable toast via the existing toast store when unavailable. Chose pull over the bundle-suggested setup-time event because the window is startup-hidden and the webview listener isn't attached when `setup` runs, so an event would be dropped (logged as a PREFERENCE escalation). Verified: cargo test, clippy -D warnings, vitest (627), tsc, eslint all green. diff --git a/_bmad-output/implementation-artifacts/epic-8-context.md b/_bmad-output/implementation-artifacts/epic-8-context.md new file mode 100644 index 0000000..bfa0630 --- /dev/null +++ b/_bmad-output/implementation-artifacts/epic-8-context.md @@ -0,0 +1,53 @@ +# Epic 8 Context: Onboarding & Platform Integration + + + +## Goal + +New users get a fast, single-instruction first-run experience and the app behaves like a reliable native citizen on every supported OS. The epic delivers a first-launch onboarding overlay that teaches the one thing that matters (the capture shortcut), guides macOS users through the accessibility permission grant the global hotkey depends on, lets users customize the hotkey before they ever leave onboarding, configures auto-start on login so Notey is always ready, enforces per-user data/socket isolation on shared machines, and verifies that all functionality works across Windows, macOS, and Linux (X11, with a Wayland fallback path). The north star is the "60-second test": a brand-new user captures their first note within a minute, with no account, email, or feature tour. + +## Stories + +- Story 8.1: First-Run Detection & Onboarding Overlay +- Story 8.2: macOS Accessibility Permission Guidance +- Story 8.3: Hotkey Customization During Onboarding +- Story 8.4: Auto-Start on Login +- Story 8.5: Per-User Data Isolation +- Story 8.6: Cross-Platform Verification & Wayland Fallback + +## Requirements & Constraints + +- First-run is detected by the absence of an `onboarding_complete` flag in config; the overlay shows only on first launch and is never shown again once dismissed (by pressing the hotkey or Esc, both of which set the flag). +- Onboarding is a single screen, not a multi-step tour: product name, key-cap visualization of the configured hotkey, "Press it now to try", and muted skip/customize affordances. No "Step X of Y". +- macOS accessibility permission is the only expected friction point; the global hotkey will not work without it. Detect the grant state, guide the user to System Settings > Privacy & Security > Accessibility, and offer a skip-with-warning. This step is skipped entirely on non-macOS platforms. +- Hotkey customization during onboarding must capture a new key combination, detect conflicts (warn and retry on conflict), and on success persist to config and re-register immediately so the rest of onboarding reflects the new shortcut. +- Auto-start must be user-toggleable, persisted in config, and survive reboot so the app launches as a tray daemon with no user action. On macOS use the LaunchAgent mechanism. +- Per-user isolation is mandatory: data, config, logs, and IPC socket all live under the current user's platform-standard directories. The Unix socket uses a user-scoped path and 0600 (owner-only) permissions; socket-file permissions are the sole isolation mechanism for v1 (no auth token). Two users on one machine must have fully independent state and cannot reach each other's socket. +- No system-wide shared directories anywhere. No network calls of any kind. +- Cross-platform parity: every functional requirement must work on Windows 10/11, macOS 12+, and Linux X11, using platform-standard paths throughout. CI must produce artifacts for all 5 targets (Windows x64, macOS x64, macOS ARM64, Linux x64, Linux ARM64). +- Wayland: if the standard global-shortcut plugin fails to register, attempt a fallback (D-Bus portal via the `ashpd` crate); if no fallback works, notify the user that the global shortcut is unavailable on their compositor. XWayland is the baseline fallback for v1. + +## Technical Decisions + +- **Platform abstraction:** A `Platform` trait centralizes all OS-divergent behavior — `data_dir()`, `config_dir()`, `log_dir()`, `socket_path()`, `register_hotkey()`, `autostart_enable/disable()`, and accessibility checks. Concrete `#[cfg(target_os)]` implementations live in `platform/linux.rs`, `platform/macos.rs`, `platform/windows.rs`. Linux handles XDG paths, Wayland portal integration, and Unix socket paths; macOS handles accessibility permissions, macOS paths, NSPanel behavior; Windows handles named pipes, registry autostart, and Windows paths. +- **Config model:** Human-readable TOML. Onboarding state lives as an `onboarding_complete` boolean; auto-start lives under `[general] auto_start = true|false`. First-run detection keys off config/flag absence — treat it as an implementation detail, not an architectural concern. +- **Auto-start plugin:** Use `tauri-plugin-autostart` (verify the current version before pinning), registered with the macOS LaunchAgent launcher. Required capability ACL permissions: `autostart:allow-enable`, `autostart:allow-disable`, `autostart:allow-is-enabled`. +- **Window lifecycle:** The main window is created hidden at startup and toggled show/hide (never destroyed) to meet the hotkey-latency target; onboarding renders as an overlay within that single window. Views (editor, search, settings, onboarding) are managed by Zustand state, not routing. +- **Frontend structure:** Onboarding components live in `src/features/onboarding/` — `OnboardingOverlay.tsx` (welcome + hotkey setup) and `AccessibilityGuide.tsx` (macOS permission guidance). Follow project conventions: feature-based dirs, no barrel files, per-feature Zustand stores, typed IPC via tauri-specta bindings only. +- **Accessibility markup:** OnboardingOverlay uses `role="dialog"`, `aria-label="Welcome to Notey"`, `aria-modal="true"`, with focus on the instruction text and Esc to dismiss. Use Radix/shadcn primitives for focus trapping and keyboard handling rather than custom logic. +- **data-testid:** Onboarding overlay must expose `data-testid="onboarding-overlay"` and the hotkey key-cap visualization `data-testid="hotkey-display"`. +- **Quality gates:** P0 tests 100%, P1 tests ≥95%, no open high-severity bugs. Favor unit/integration tests; E2E is rationed — the first-run onboarding flow (P1-E2E-002: overlay display, hotkey-press dismissal, config persistence) is one of only 3 permitted E2E journeys across the whole product. Cross-platform work also carries visual-regression expectations on CI builds for all 3 platforms. + +## UX & Interaction Patterns + +- **First-run flow:** App detects first run -> main window opens with onboarding overlay -> (macOS only) accessibility guidance if permission not granted -> user presses the hotkey to dismiss the overlay and start their first capture; pressing Esc instead also completes onboarding (app minimizes to tray, user discovers the hotkey later via the tray menu). Onboarding never reappears. +- **Hotkey customization in onboarding:** A muted "Customize" affordance below the key caps enters a capture mode ("Press your preferred shortcut..."), updates the key caps live, validates for conflicts, and continues onboarding with the new shortcut once saved. +- **Progressive disclosure:** For the user's first 5 sessions, the StatusBar shows a "Ctrl+P for commands" hint in `var(--text-muted)`; it disappears permanently after the 5th session. (Track session count to drive this.) +- **Visual style:** Onboarding text and chrome may use the secondary proportional sans-serif stack (editor/note content stays monospace). Minimal, dense, single-screen presentation consistent with the rest of the app's tokens. + +## Cross-Story Dependencies + +- The configured hotkey shown and registered here is the same global-shortcut/window-summon machinery built in Epic 1 (Story 1.11); onboarding reuses and reconfigures it rather than reimplementing it. Hotkey conflict detection overlaps with Epic 7's hotkey configuration work — share the validation/registration path. +- Story 8.2 (macOS permission) and Story 8.3 (customization) are conditional enhancements layered onto the Story 8.1 overlay; 8.1 should expose the overlay states (`visible`, `macos-permission`, `dismissed`) those stories plug into. +- Story 8.5 (per-user paths/socket) and Story 8.6 (platform trait) are foundational to features built earlier: the data/config/log paths underpin Epic 1's database location and the socket path underpins Epic 6's CLI-to-app IPC. Coordinate so path/socket resolution has a single source of truth in the `Platform` abstraction. +- Story 8.6 is the integration capstone for the epic and the product — it verifies that FRs from all prior epics behave correctly per platform and that CI emits all 5 target artifacts. diff --git a/_bmad-output/implementation-artifacts/spec-8-1-first-run-detection-onboarding-overlay.md b/_bmad-output/implementation-artifacts/spec-8-1-first-run-detection-onboarding-overlay.md new file mode 100644 index 0000000..2428a7c --- /dev/null +++ b/_bmad-output/implementation-artifacts/spec-8-1-first-run-detection-onboarding-overlay.md @@ -0,0 +1,135 @@ +--- +title: "Story 8.1 — First-Run Detection & Onboarding Overlay" +type: "feature" +created: "2026-06-17" +status: "done" +baseline_commit: "d5a65b67397e98daa4a90fc1e2d3ca6020eed796" +context: + - "{project-root}/_bmad-output/implementation-artifacts/epic-8-context.md" + - "{project-root}/_bmad-output/project-context.md" +--- + + + +## Intent + +**Problem:** A brand-new user launches Notey to a blank editor with no indication of how to summon the app. The capture global-shortcut — the single thing a new user must learn — is invisible, and the codebase has only RED-PHASE stubs for onboarding (backend service with `todo!`, frontend store/api/component shells, and `#[ignore]`/`describe.skip` acceptance tests). + +**Approach:** Implement the green phase of the first-run onboarding slice. Persist onboarding state (`complete`, `sessions_seen`) to `onboarding.toml` in the platform config dir; on first run, show the main window with a centered accessible overlay that teaches the configured capture shortcut as key caps; dismiss-and-persist-completion on Esc or hotkey press; and show a transient "Ctrl+P for commands" status-bar hint for the user's first 5 sessions. The overlay is the **complete visual shell** for the whole epic — it renders the Customize (8.3) and macOS-accessibility (8.2) states so those stories only wire their backends — but this story implements no macOS-permission detection and no hotkey capture/conflict/re-registration logic. + +## Boundaries & Constraints + +**Always:** +- Persist onboarding state atomically to `onboarding.toml` (temp-file + rename), sibling to `config.toml`, mirroring `services::config::save`. Missing/corrupt file → default state, never an error. +- First-run detection keys solely off `onboarding.complete == false`. Onboarding is shown once and never again once `complete` is set. +- All IPC via tauri-specta generated `commands.*` bindings — never raw `invoke()`. New commands need `#[serde(rename_all = "camelCase")]` boundary types, a permission TOML, a `capabilities/default.json` entry, and an `EXPECTED_COMMANDS` entry in `acl_tests.rs`. +- Tauri command handlers stay thin & synchronous; all logic lives in `services::onboarding`. +- The overlay must expose `data-testid="onboarding-overlay"` and `data-testid="hotkey-display"`, with `role="dialog"`, `aria-modal="true"`, `aria-label="Welcome to Notey"`, focus-trapped via the existing `useFocusTrap` hook. +- The command-hint gate is exactly `sessions_seen < COMMAND_HINT_SESSION_LIMIT` (=5); `sessions_seen` is the count of *prior* sessions (incremented once per launch AFTER the overlay reads it), so the hint shows for the first 5 launches. +- Zero network access; reuse the existing global-shortcut machinery (no reimplementation). + +**Ask First:** +- Changing the frozen `OnboardingState` field names/shape, the `onboarding.toml` filename/location, or the `COMMAND_HINT_SESSION_LIMIT` value. +- Introducing any new runtime dependency. + +**Never:** +- Do NOT implement Story 8.2 backend (macOS accessibility permission detection / "open System Settings" command) or Story 8.3 backend (hotkey capture parsing, conflict detection, persistence, live re-registration). Render their overlay states as inert shell only; wire the "System Settings" button and the customize-capture to documented `TODO(Story 8.2/8.3)` handlers. +- Do NOT add a new E2E test (P1-E2E-002 is owned by a later cross-platform pass; component/store/integration layers cover this story). +- Do NOT mutate `AppConfig` / `config.toml` for onboarding state — onboarding has its own file. +- No raw `app.emit` with stringly names — the hotkey-press event must be a typed `tauri_specta::Event`. + +## I/O & Edge-Case Matrix + +| Scenario | Input / State | Expected Output / Behavior | Error Handling | +| --- | --- | --- | --- | +| First run | no `onboarding.toml` | `load` → `{complete:false, sessions_seen:0}`; window shown with overlay | missing/corrupt file → default state, no error | +| Mark complete + reload | `mark_complete` then fresh `is_complete` | `true`; `onboarding.toml` exists on disk | atomic temp+rename write | +| Idempotent completion | `increment_session` then `mark_complete` twice | `complete==true`, `sessions_seen==1` (not reset) | N/A | +| Session counting | `increment_session` ×2, reload | returns `1` then `2`; persists across reload | N/A | +| Command-hint gate | `sessions_seen` 0..4 vs ≥5 | `should_show_command_hint` true for `<5`, false for `≥5` (permanently) | N/A | +| Dismiss (Esc or hotkey) | overlay visible | `dismiss()` persists `complete=true`, hides overlay, never reshown on re-show | `completeOnboarding` failure logged; overlay still hides | +| Already onboarded | `complete==true` at launch | overlay stays hidden (`isVisible=false`) | N/A | + + + +## Code Map + +- `src-tauri/src/services/onboarding.rs` -- service: replace 5 `todo!` stubs (`load`, `is_complete`, `mark_complete`, `increment_session`, `should_show_command_hint`) with atomic TOML persistence; update the RED-PHASE module doc. +- `src-tauri/tests/onboarding_tests.rs` -- 5 `#[ignore]` integration tests encoding the service contract; remove the `#[ignore]` attributes to activate. +- `src-tauri/src/commands/onboarding.rs` -- NEW thin commands: `get_onboarding_state`, `complete_onboarding`, `increment_onboarding_session`, all over `State`. +- `src-tauri/src/commands/mod.rs` -- add `pub mod onboarding;`. +- `src-tauri/src/ipc/events.rs` -- add typed `HotkeyPressed` event (kebab `hotkey-pressed`), mirroring `NoteCreated`. +- `src-tauri/src/lib.rs` -- register the 3 commands + `HotkeyPressed` event in `specta_builder`; on first run (onboarding not complete) show+center+focus the main window; emit `HotkeyPressed` in the global-shortcut `Pressed` handler. +- `src-tauri/permissions/autogenerated/*.toml` + `src-tauri/capabilities/default.json` + `src-tauri/tests/acl_tests.rs` -- ACL wiring for the 3 new commands. +- `src/features/onboarding/api.ts` -- wire the 3 functions to generated bindings (replace `not implemented` throws). +- `src/features/onboarding/store.ts` -- already orchestrates correctly; no change expected beyond verification. +- `src/features/onboarding/components/OnboardingOverlay.tsx` -- implement the full overlay shell markup + Esc/hotkey-event dismissal + focus trap. +- `src/features/onboarding/bootstrap.ts` -- NEW: `initOnboarding()` — read config hotkey, `store.init(hotkey)`, then record the session once (StrictMode-guarded). +- `src/App.tsx` -- call `initOnboarding()` in the startup effect. +- `src/features/editor/components/CaptureWindow.tsx` -- render `` in the relative container. +- `src/features/editor/components/StatusBar.tsx` -- render the "Ctrl+P for commands" hint in `var(--text-muted)` when `shouldShowCommandHint()`. +- `src/features/onboarding/store.test.ts` & `OnboardingOverlay.test.tsx` -- flip `describe.skip` → `describe` to activate. + +## Tasks & Acceptance + +**Execution:** + +- [x] `src-tauri/src/services/onboarding.rs` -- Implement `load` (read+parse TOML, default on missing/corrupt), `is_complete`, `mark_complete` (set flag, atomic write, idempotent — preserve `sessions_seen`), `increment_session` (load, bump, persist, return new count), `should_show_command_hint` (`state.sessions_seen < COMMAND_HINT_SESSION_LIMIT`); refresh the module doc to drop the stub language. -- Backend persistence core. +- [x] `src-tauri/tests/onboarding_tests.rs` -- Remove all 5 `#[ignore]` attributes. -- Activate the red-phase contract. +- [x] `src-tauri/src/commands/onboarding.rs` + `commands/mod.rs` -- Add thin sync commands delegating to the service via `State`; return `OnboardingState` / `()` / `u32`. -- IPC surface. +- [x] `src-tauri/src/ipc/events.rs` -- Add `HotkeyPressed` typed event (empty/marker payload) + a name unit test (`hotkey-pressed`). -- Reliable hotkey-press signal to the webview. +- [x] `src-tauri/src/lib.rs` -- Register the 3 commands + `HotkeyPressed` in `specta_builder`; after managing `ConfigDir`, show the main window when `!onboarding::is_complete(...)`; emit `HotkeyPressed` from the shortcut `Pressed` handler. -- Wiring + first-run window show. +- [x] `src-tauri/permissions/autogenerated/{get_onboarding_state,complete_onboarding,increment_onboarding_session}.toml`, `capabilities/default.json`, `tests/acl_tests.rs` -- Add allow-permissions + `EXPECTED_COMMANDS` entries. -- Default-deny ACL. +- [x] `src/features/onboarding/api.ts` -- Replace throws with `commands.getOnboardingState()`, `commands.completeOnboarding()`, `commands.incrementOnboardingSession()` (unwrap `Result`). -- Frontend bridge. +- [x] `src/features/onboarding/components/OnboardingOverlay.tsx` -- Render centered `role="dialog"` overlay: "Your capture shortcut is" + key caps split from the hotkey string (`data-testid="hotkey-display"`) + "Press it now to try"; muted Customize control → `startCustomize()` showing "Press your preferred shortcut…"; macOS guidance block (shell) shown when `accessibilityNeeded`, with the permission text, a "System Settings" button (`TODO(8.2)`), and the skip-with-warning text; Esc keydown and `events.hotkeyPressed` listener → `dismiss()`; focus-trap via `useFocusTrap`. -- The overlay UI. +- [x] `src/features/onboarding/bootstrap.ts` + `src/App.tsx` -- `initOnboarding()`: `getConfig()` → hotkey → `store.init(hotkey)` → record session once (module-flag guarded). Call from the App startup effect. -- First-run wiring + session counting. +- [x] `src/features/editor/components/CaptureWindow.tsx` -- Mount ``. -- Show the overlay. +- [x] `src/features/editor/components/StatusBar.tsx` -- Add the `var(--text-muted)` "Ctrl+P for commands" hint gated on `useOnboardingStore(s => s.shouldShowCommandHint())`. -- Progressive disclosure. +- [x] `src/features/onboarding/store.test.ts` & `OnboardingOverlay.test.tsx` -- Activate (`describe.skip` → `describe`). -- Lock the contract. + +### Review Findings + +- [x] [Review][Patch] Completion can be lost by a startup/dismiss race [src-tauri/src/services/onboarding.rs:76] +- [x] [Review][Patch] Dismiss failure leaves overlay visible [src/features/onboarding/store.ts:72] +- [x] [Review][Patch] Onboarding can show an empty shortcut instruction [src/features/onboarding/bootstrap.ts:28] +- [x] [Review][Patch] Retired command hint can flash before onboarding init resolves [src/features/editor/components/StatusBar.tsx:18] +- [x] [Review][Patch] Persisted onboarding TOML uses `sessionsSeen` instead of frozen `sessions_seen` [src-tauri/src/services/onboarding.rs:30] +- [x] [Review][Patch] Dialog focus is not moved into the instruction/focus trap on open [src/features/onboarding/components/OnboardingOverlay.tsx:23] + +#### Review Ledger (2026-06-17) + +- patch: Completion can be lost by a startup/dismiss race [src-tauri/src/services/onboarding.rs:76] -- concurrent session increment and completion both read-modify-write `onboarding.toml`, so a stale increment can clear completion. +- patch: Dismiss failure leaves overlay visible [src/features/onboarding/store.ts:72] -- `dismiss()` hides only after `completeOnboarding()` succeeds, contrary to the required failure behavior. +- patch: Onboarding can show an empty shortcut instruction [src/features/onboarding/bootstrap.ts:28] -- config load failure leaves `hotkey` empty while the overlay still renders the try prompt. +- patch: Retired command hint can flash before onboarding init resolves [src/features/editor/components/StatusBar.tsx:18] -- the store defaults `sessionsSeen` to 0, so already-retired users can briefly see the hint before persisted state loads. +- patch: Persisted onboarding TOML uses `sessionsSeen` instead of frozen `sessions_seen` [src-tauri/src/services/onboarding.rs:30] -- the IPC struct's camelCase serde naming is reused for TOML persistence. +- patch: Dialog focus is not moved into the instruction/focus trap on open [src/features/onboarding/components/OnboardingOverlay.tsx:23] -- the current hook traps tabbing only and the component explicitly leaves focus on the editor. + +**Acceptance Criteria:** + +- Given a fresh config dir, when the app starts, then the main window is shown with the onboarding overlay rendered (dialog markup + key caps + try prompt) and `onboarding.toml` reports not-complete. +- Given the overlay is visible, when the user presses Esc or the configured hotkey, then `onboarding_complete` is persisted, the overlay hides, and it never reappears (including after a window hide/show cycle). +- Given onboarding is already complete, when the app starts, then no overlay is shown. +- Given the user is within their first 5 sessions, when the StatusBar renders, then the "Ctrl+P for commands" hint appears in `var(--text-muted)`; from the 6th session it is gone permanently. +- Given the build, when bindings regenerate and the suites run, then `cargo test`, `vitest`, clippy, and tsc all pass with the previously-ignored/skipped onboarding tests now active. + +## Design Notes + +**Session-count off-by-one:** `store.init` reads the *prior* `sessions_seen` and seeds the hint; `bootstrap` then increments for the next launch. So launch 1 reads 0 (shows), … launch 5 reads 4 (shows), launch 6 reads 5 (hidden) — exactly "first 5 sessions." Guard the increment with a module-level boolean so React StrictMode's double-mount doesn't double-count. + +**Hotkey-press dismissal:** the OS global shortcut hides the window via the existing `toggle_main_window`, but the React tree is *not* reloaded, so the frontend must learn of the press to flip `isVisible` and persist completion. The shortcut handler emits the typed `HotkeyPressed` event; the visible overlay's `events.hotkeyPressed.listen(...)` calls `dismiss()`. Relying on a webview keydown for a registered global shortcut is unreliable cross-platform — the event is the source of truth. + +**Key-cap split (golden):** +```tsx +{hotkey.split('+').map((k) => {k.trim()})} +``` + +## Verification + +**Commands:** + +- `cd src-tauri && cargo test --test onboarding_tests` -- expected: all 5 (de-ignored) pass. +- `cd src-tauri && cargo test` -- expected: full backend suite green (incl. `acl_tests`, `export_bindings` regen of `bindings.ts`). +- `cd src-tauri && cargo clippy --all-targets -- -D warnings` -- expected: no warnings. +- `npm test -- src/features/onboarding src/features/editor/components/StatusBar.test` -- expected: activated onboarding store/overlay tests + StatusBar pass. +- `npm run build` -- expected: `tsc` + vite build succeed (bindings include the 3 new commands + `hotkeyPressed`). diff --git a/_bmad-output/implementation-artifacts/spec-8-2-macos-accessibility-permission-guidance.md b/_bmad-output/implementation-artifacts/spec-8-2-macos-accessibility-permission-guidance.md new file mode 100644 index 0000000..6d6a888 --- /dev/null +++ b/_bmad-output/implementation-artifacts/spec-8-2-macos-accessibility-permission-guidance.md @@ -0,0 +1,126 @@ +--- +title: "Story 8.2 — macOS Accessibility Permission Guidance" +type: "feature" +created: "2026-06-17" +status: "done" +baseline_commit: "a722759a78999fb1c9ddc9720656de2e378dc085" +context: + - "{project-root}/_bmad-output/implementation-artifacts/epic-8-context.md" + - "{project-root}/_bmad-output/project-context.md" +--- + + + +## Intent + +**Problem:** On macOS the global capture hotkey silently fails until the user grants the OS *Accessibility* permission, yet Story 8.1 left the onboarding guidance state as an inert shell — no permission detection, the "Open System Settings" button is a `TODO(Story 8.2)`, and there is no skip affordance. A macOS first-run user has no path from "the shortcut doesn't work" to a working capture hotkey. + +**Approach:** Implement the green phase of the macOS accessibility flow behind the existing `Platform` trait: a real `accessibility_permission_granted()` (via `AXIsProcessTrusted`) and `open_accessibility_settings()` (open the Privacy → Accessibility pane), exposed through two thin Tauri commands. Wire onboarding to detect a missing grant on first run, render the existing guidance with a working Settings button plus a Skip affordance, and poll so that granting permission auto-dismisses the guidance and onboarding continues. Non-macOS platforms report the permission as granted, so the step is skipped entirely with no OS branching in the frontend. + +## Boundaries & Constraints + +**Always:** +- macOS detection uses `AXIsProcessTrusted()` linked from the system `ApplicationServices` framework via a small `extern "C"` FFI block — no new crate. The settings pane is opened with the `x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility` URL. +- All OS-divergent logic stays behind the existing `Platform` trait (`accessibility_permission_granted`, `open_accessibility_settings`). The two new Tauri commands are thin **synchronous** handlers that delegate to `platform::current()` — no business logic in handlers. +- The frontend never branches on OS. "Skip entirely on non-macOS" is derived from the backend returning `Ok(true)` (granted) — the existing Linux/Windows impls already do this; keep them. +- New commands require: a permission TOML in `permissions/autogenerated/`, an `allow-*` entry in `capabilities/default.json`, an `EXPECTED_COMMANDS` entry in `acl_tests.rs`, and registration in `specta_builder`. `bindings.ts` is regenerated by `cargo test` (never hand-edited). +- All IPC via generated `commands.*` bindings — never raw `invoke()`. +- Accessibility detection runs only when the onboarding overlay is shown (first run). Granting permission auto-dismisses the guidance by calling `setAccessibilityNeeded(false)`; onboarding then shows the normal hotkey instruction. +- Every accessibility IPC call on the frontend is guarded (try/catch or `.catch`) so a missing Tauri runtime (unit tests) or a failed check cannot crash render or block startup — a failed check is treated as "granted" so onboarding is never blocked. + +**Ask First:** +- Changing the settings-pane URL, the FFI symbol (`AXIsProcessTrusted`), or the linked framework (`ApplicationServices`). +- Changing any `Platform` trait method signature (shared with the still-stubbed Stories 8.4/8.5/8.6 methods). +- Introducing any new runtime dependency (the FFI approach needs none). + +**Never:** +- Do NOT implement Story 8.3 (hotkey capture/conflict/re-registration) or the 8.4/8.5/8.6 `Platform` methods — leave those `todo!` stubs intact; only fill the two accessibility methods on macOS. +- Do NOT gate Esc/hotkey dismissal on the permission state — skipping must always remain possible. +- Do NOT add a new E2E test (P1-E2E-002 is owned by the later cross-platform pass). +- Do NOT block startup on the accessibility check (best-effort, like the Story 8.1 session increment). +- No raw `invoke`, no network calls, no broad FS permissions. + +## I/O & Edge-Case Matrix + +| Scenario | Input / State | Expected Output / Behavior | Error Handling | +| --- | --- | --- | --- | +| macOS, granted | first run, `AXIsProcessTrusted` true | `accessibilityNeeded=false`; normal hotkey instruction shown | N/A | +| macOS, denied | first run, `AXIsProcessTrusted` false | guidance shown: permission message + "Open System Settings" + "Skip for now" + warning text | N/A | +| Open settings click | guidance visible | `open_accessibility_settings` spawns the settings URL | spawn failure → `Err(Io)` logged; button remains | +| Grant detected | guidance visible, poll/focus re-check sees granted | `setAccessibilityNeeded(false)`; guidance dismissed; normal instruction shown | check error → keep guidance, retry next tick | +| Skip | guidance visible, user clicks "Skip for now" | `accessibilityNeeded=false`; normal instruction shown (onboarding continues) | N/A | +| Non-macOS | first run, `granted() == Ok(true)` | guidance never shown; onboarding shows hotkey instruction | N/A | +| Check fails / no runtime | first run, IPC throws | treated as granted; onboarding proceeds; error logged | swallow + log, never block | +| Already onboarded | `complete == true` | overlay hidden; no accessibility check performed | N/A | + + + +## Code Map + +- `src-tauri/src/platform/macos.rs` -- Implement `accessibility_permission_granted` (FFI `AXIsProcessTrusted`) and `open_accessibility_settings` (open the Privacy→Accessibility URL via `open`). Leave the 8.4/8.5/8.6 `todo!` methods untouched. +- `src-tauri/src/platform/linux.rs` / `windows.rs` -- No change; already return `Ok(true)` / no-op for the two methods (non-macOS skip path). +- `src-tauri/src/commands/accessibility.rs` -- NEW thin sync commands `check_accessibility_permission` (→ `Result`) and `open_accessibility_settings` (→ `Result<()>`), each delegating to `platform::current()`. +- `src-tauri/src/commands/mod.rs` -- Add `pub mod accessibility;`. +- `src-tauri/src/lib.rs` -- Register the 2 commands in `specta_builder`'s `collect_commands!`. +- `src-tauri/permissions/autogenerated/check_accessibility_permission.toml` + `open_accessibility_settings.toml` -- NEW allow/deny permission sets (mirror existing onboarding TOMLs). +- `src-tauri/capabilities/default.json` -- Add `allow-check-accessibility-permission`, `allow-open-accessibility-settings`. +- `src-tauri/tests/acl_tests.rs` -- Add the same two identifiers to `EXPECTED_COMMANDS`. +- `src-tauri/tests/platform_tests.rs` -- Remove `#[ignore]` from the three Story 8.2 tests (`macos_reports_accessibility_permission`, `macos_can_open_accessibility_settings`, `non_macos_skips_accessibility_gate`). +- `src/features/onboarding/api.ts` -- Add `checkAccessibilityPermission(): Promise` and `openAccessibilitySettings(): Promise` over the generated bindings. +- `src/features/onboarding/bootstrap.ts` -- After `store.init`, if the overlay is visible, best-effort check permission and `setAccessibilityNeeded(!granted)`. +- `src/features/onboarding/components/OnboardingOverlay.tsx` -- Wire the Settings button to `openAccessibilitySettings`; add a "Skip for now" button → `setAccessibilityNeeded(false)`; poll (interval + window `focus`) while the guidance is shown to auto-dismiss on grant. +- `src/features/onboarding/components/OnboardingOverlay.test.tsx` -- Add tests: Settings button invokes the open command; Skip clears `accessibilityNeeded`; a focus/poll re-check that sees a grant dismisses the guidance. +- `src/generated/bindings.ts` -- Regenerated by `cargo test` (the `export_bindings` test); do not hand-edit. + +## Tasks & Acceptance + +**Execution:** + +- [x] `src-tauri/src/platform/macos.rs` -- Replace the two `todo!` accessibility methods: `accessibility_permission_granted` calls a `#[link(name = "ApplicationServices", kind = "framework")] extern "C" { fn AXIsProcessTrusted() -> u8; }` and returns `Ok(unsafe { AXIsProcessTrusted() } != 0)`; `open_accessibility_settings` spawns `open ` mapping spawn failure to `NoteyError::Io`. -- Real macOS permission detection + settings deep-link. +- [x] `src-tauri/src/commands/accessibility.rs` + `commands/mod.rs` -- Add the two thin `#[tauri::command] #[specta::specta]` sync handlers delegating to `platform::current()`. -- IPC surface. +- [x] `src-tauri/src/lib.rs` -- Register both commands in `collect_commands!`. -- Wiring + bindings regen. +- [x] `src-tauri/permissions/autogenerated/{check_accessibility_permission,open_accessibility_settings}.toml`, `capabilities/default.json`, `tests/acl_tests.rs` -- Add allow/deny permission sets, capability entries, and `EXPECTED_COMMANDS` entries. -- Default-deny ACL stays consistent. +- [x] `src-tauri/tests/platform_tests.rs` -- Remove `#[ignore]` from the three Story 8.2 tests. -- Activate the red-phase contract (`non_macos_skips_accessibility_gate` runs on Linux CI now). +- [x] `src/features/onboarding/api.ts` -- Add `checkAccessibilityPermission` / `openAccessibilitySettings` wrapping `commands.checkAccessibilityPermission()` / `commands.openAccessibilitySettings()` (unwrap `Result`). -- Frontend bridge. +- [x] `src/features/onboarding/bootstrap.ts` -- After `store.init(hotkey)`, when `isVisible`, best-effort `checkAccessibilityPermission()` → `setAccessibilityNeeded(!granted)`; swallow+log errors. -- First-run detection. +- [x] `src/features/onboarding/components/OnboardingOverlay.tsx` -- Settings button → `void openAccessibilitySettings()`; add "Skip for now" button → `setAccessibilityNeeded(false)` (keeping the warning text); while `isVisible && accessibilityNeeded`, poll (interval + window `focus`) `checkAccessibilityPermission()` and call `setAccessibilityNeeded(false)` on a grant; guard all calls. -- Working guidance + auto-dismiss-on-grant + skip. +- [x] `src/features/onboarding/components/OnboardingOverlay.test.tsx` -- Add tests for the Settings-button command call, the Skip control, and grant-detected auto-dismiss. -- Lock the 8.2 UI contract. + +**Acceptance Criteria:** + +- Given the app runs on macOS and the overlay is shown, when accessibility permission is NOT granted, then the overlay shows the guidance message, a working "Open System Settings" button, and a skip option with the "shortcut may not work without this permission" warning. +- Given the macOS guidance is visible, when the user grants permission (detected by the re-check), then `accessibilityNeeded` clears and onboarding shows the normal hotkey instruction without a reload. +- Given the macOS guidance is visible, when the user clicks "Skip for now", then the guidance is dismissed, onboarding continues, and Esc/hotkey dismissal still works throughout. +- Given the app is NOT running on macOS, when onboarding runs, then `accessibility_permission_granted()` returns `Ok(true)`, no guidance is shown, and the accessibility step is skipped entirely with no OS branching in the frontend. +- Given the build, when bindings regenerate and the suites run, then `cargo test` (incl. `acl_tests`, de-ignored `platform_tests` 8.2 cases), `cargo clippy`, `vitest`, and `tsc` all pass. + +## Design Notes + +**FFI return type:** Apple's `AXIsProcessTrusted` returns `Boolean` (`typedef unsigned char`). Declare it `-> u8` and compare `!= 0` rather than `-> bool` — a Rust `bool` is UB for any byte other than 0/1, and `u8`+compare is the safe idiom. The `extern` block and call site are the only `unsafe` in the change; keep them minimal and documented. + +**Non-macOS "skip" is data, not a branch:** Because `LinuxPlatform`/`WindowsPlatform::accessibility_permission_granted` already return `Ok(true)`, the same `checkAccessibilityPermission()` call yields `granted=true` everywhere but macOS, so `setAccessibilityNeeded(!granted)` is a no-op off macOS. The frontend stays OS-agnostic and the test `non_macos_skips_accessibility_gate` pins this on Linux CI. + +**Auto-dismiss on grant:** macOS emits no event when permission changes, so the overlay polls while the guidance is shown — a short interval plus a window `focus` listener (the user returns from System Settings) — re-checking `checkAccessibilityPermission()`. On the first `true`, `setAccessibilityNeeded(false)` swaps the guidance for the normal hotkey instruction. The effect is keyed on `isVisible && accessibilityNeeded` so it stops the moment guidance closes. + +## Verification + +**Commands:** + +- `cd src-tauri && cargo test` -- expected: full backend suite green, incl. `acl_tests`, the de-ignored `platform_tests::non_macos_skips_accessibility_gate` (runs on Linux), and `export_bindings` regenerating `bindings.ts` with the 2 new commands. +- `cd src-tauri && cargo clippy --all-targets -- -D warnings` -- expected: no warnings. +- `npm test -- src/features/onboarding` -- expected: existing + new onboarding store/overlay tests pass. +- `npm run build` -- expected: `tsc` + vite build succeed (bindings include `checkAccessibilityPermission` + `openAccessibilitySettings`). + +**Manual checks (macOS, not runnable on this Linux host):** + +- On a macOS build with permission revoked, first run shows the guidance; "Open System Settings" opens Privacy → Accessibility; granting it dismisses the guidance and reveals the hotkey instruction. + +### Review Findings + +- [x] [Review][Patch] Reap and validate macOS settings opener [src-tauri/src/platform/macos.rs:70] + +#### Review Ledger (2026-06-17) + +- patch: Reap and validate macOS settings opener [src-tauri/src/platform/macos.rs:70] — fixed by waiting for the short-lived `open` helper, reporting nonzero exit, and reaping the child process. +- dismiss: macOS settings-opening test has a desktop side effect [src-tauri/tests/platform_tests.rs:105] — the approved story explicitly de-ignored this macOS-only acceptance test, so the side effect is an accepted platform-test behavior rather than an implementation bug. +- dismiss: Failed permission re-check can leave guidance stuck [src/features/onboarding/components/OnboardingOverlay.tsx:82] — the approved matrix says re-check errors keep guidance visible and retry; the first-run bootstrap failure path starts from `accessibilityNeeded=false`, so onboarding proceeds. diff --git a/_bmad-output/implementation-artifacts/spec-8-3-hotkey-customization-during-onboarding.md b/_bmad-output/implementation-artifacts/spec-8-3-hotkey-customization-during-onboarding.md new file mode 100644 index 0000000..55d94a6 --- /dev/null +++ b/_bmad-output/implementation-artifacts/spec-8-3-hotkey-customization-during-onboarding.md @@ -0,0 +1,115 @@ +--- +title: "Story 8.3 — Hotkey Customization During Onboarding" +type: "feature" +created: "2026-06-17" +status: "done" +baseline_commit: "89e39fc3282e7dfdcd238ba355d8660e2d9f444a" +context: + - "{project-root}/_bmad-output/implementation-artifacts/epic-8-context.md" + - "{project-root}/_bmad-output/project-context.md" +--- + + + +## Intent + +**Problem:** Story 8.1 shipped the onboarding overlay's "Customize" affordance as an inert shell: clicking it flips `customizing` and shows the static "Press your preferred shortcut…" prompt, but there is no key capture, no conflict handling, and `applyCustomHotkey` only mutates the displayed string locally — it never persists or re-registers the global shortcut. A new user cannot actually change the capture hotkey before leaving onboarding. + +**Approach:** Implement the green phase of in-onboarding hotkey customization purely on the frontend by reusing Epic 7's existing register-before-commit path. In the overlay's `customizing` branch, capture a modifier+key combination with the existing `formatShortcutFromEvent` grammar, live-preview it as key caps, and on an explicit Save delegate to the shared `useSettingsStore.setGlobalShortcut()` (which calls `commands.updateConfig` — validate → register-new → unregister-old → persist). A conflict keeps the previous shortcut and surfaces an inline warning so the user can retry; success updates the displayed shortcut and continues onboarding. No backend, command, or dependency changes. + +## Boundaries & Constraints + +**Always:** +- Persist + register the new shortcut ONLY through `useSettingsStore.getState().setGlobalShortcut(combo)` — the single Epic 7 register-before-commit path (it already does conflict detection, unregister-old, atomic persist, and returns `true`/`false`). Never call `commands.updateConfig` directly from onboarding and never reimplement parsing/conflict logic. +- Derive captured combos with the existing `formatShortcutFromEvent` + supported-key set from `src/features/settings/shortcut.ts` (canonical `Ctrl|Cmd + Shift + Alt + KEY`). No new capture grammar. +- Capture uses a window keydown listener in the **capture phase** with `preventDefault` + `stopPropagation`, mirroring `HotkeyCaptureField`: ignore Tab and bare-modifier presses; an unsupported/modifier-less combo shows an inline warning rather than capturing. +- Register only on an explicit Save/confirm action — never auto-register on each keypress. +- On conflict/failure: keep the previously displayed-and-registered shortcut, show an inline warning (`role="alert"`), and stay in capture mode so the user can try again. On success: set the overlay `hotkey` to the captured combo, leave capture mode, and continue onboarding. +- While `customizing`, suppress the overlay's Esc-dismiss and `hotkey-pressed`-dismiss so capture is never interrupted; Esc cancels capture only. Outside capture, Story 8.1 Esc/hotkey dismissal is unchanged. +- All IPC stays via generated `commands.*` bindings (transitively through the settings store). Zero raw `invoke`, zero network, no broad FS. + +**Ask First:** +- Changing the shared `setGlobalShortcut` contract or the `formatShortcutFromEvent` grammar (both shared with Settings / Epic 7). +- Introducing any backend code, new Tauri command, or new runtime dependency (none expected — this story is frontend-only reuse). + +**Never:** +- Do NOT add Rust, a new Tauri command, ACL/permission entries, or a new `onboarding/api.ts` function — the registration + conflict + persistence path already exists in Epic 7's `update_config`. +- Do NOT auto-apply the shortcut on every captured keystroke (no register spam). +- Do NOT add a new E2E test (P1-E2E-002 is owned by the later cross-platform pass). +- Do NOT gate Story 8.1's Esc/hotkey onboarding dismissal outside capture mode. +- Do NOT mutate `onboarding.toml` or `AppConfig`/`config.toml` directly for the shortcut. + +## I/O & Edge-Case Matrix + +| Scenario | Input / State | Expected Output / Behavior | Error Handling | +| --- | --- | --- | --- | +| Enter capture | click "Customize" | `customizing=true`; "Press your preferred shortcut…" shown; capture listener active; Save disabled | N/A | +| Valid combo pressed | `Ctrl+Shift+J` in capture | live-preview key caps update to the combo; Save enabled; warning cleared | N/A | +| Invalid press | bare `J`, pure modifier, or unsupported key | nothing captured; inline warning to use a modifier + letter/number; Save stays disabled | swallow, warn inline | +| Save, no conflict | Save with captured combo | `setGlobalShortcut`→`true`; overlay `hotkey` = new combo; capture exits; onboarding continues with new caps | N/A | +| Save, conflict/failure | `setGlobalShortcut`→`false` | inline warning shown; remains in capture; displayed + registered shortcut unchanged | keep old, allow retry | +| Cancel capture | "Cancel" button | capture exits; original hotkey still displayed; onboarding NOT dismissed | N/A | +| Esc during capture | Esc keydown while `customizing` | cancels capture only; onboarding stays open | stopPropagation blocks dismiss | +| Global hotkey press during capture | backend `hotkey-pressed` while `customizing` | ignored — no dismiss until capture exits | listener gated off | + + + +## Code Map + +- `src/features/onboarding/store.ts` -- Make `applyCustomHotkey` async returning `Promise`: delegate to `useSettingsStore.getState().setGlobalShortcut(combo)`; on `true` `set({ hotkey: combo, customizing: false })` and return `true`; on `false` leave `customizing` true (retry) and return `false`. Add `cancelCustomize: () => set({ customizing: false })`. Update the `OnboardingActions` interface + JSDoc and drop the RED-PHASE note now that the slice is green. +- `src/features/onboarding/components/OnboardingOverlay.tsx` -- Implement the real `customizing` branch: local `captured`/`warning` state; a capture-phase window `keydown` handler using `formatShortcutFromEvent` (ignore Tab + bare modifiers, Esc→`cancelCustomize`, invalid→warning, valid→live preview); render the live key-cap preview + Save (disabled until captured) + Cancel + inline warning; Save → `await applyCustomHotkey(captured)` then warn-and-stay on `false`. Gate the existing Esc-dismiss and `hotkey-pressed` effects on `!customizing`. +- `src/features/settings/shortcut.ts` -- REUSE `formatShortcutFromEvent` (no change). +- `src/features/settings/store.ts` -- REUSE `setGlobalShortcut` (no change). +- `src/features/onboarding/store.test.ts` -- Replace the stub `applyCustomHotkey` test with async cases mocking `useSettingsStore.getState().setGlobalShortcut` (success updates hotkey + exits capture; conflict keeps hotkey + stays in capture + returns `false`); add a `cancelCustomize` test. +- `src/features/onboarding/components/OnboardingOverlay.test.tsx` -- Add capture-flow tests: valid press shows live preview + enables Save; invalid press shows the warning; Save (success) calls `setGlobalShortcut`, shows the new key caps, and exits capture; Save (conflict) shows the warning and stays in capture; Cancel and Esc cancel capture without dismissing onboarding. + +## Tasks & Acceptance + +**Execution:** + +- [x] `src/features/onboarding/store.ts` -- Convert `applyCustomHotkey` to the async delegating action and add `cancelCustomize` (interface + impl + JSDoc); refresh the store doc comment. -- Onboarding-side orchestration over the shared registration path. +- [x] `src/features/onboarding/components/OnboardingOverlay.tsx` -- Implement capture-mode keydown + live preview + Save/Cancel + inline warning in the `customizing` branch and gate the Esc/`hotkey-pressed` dismiss effects on `!customizing`. -- The customization UI. +- [x] `src/features/onboarding/store.test.ts` -- Update/add store tests for async `applyCustomHotkey` (success + conflict) and `cancelCustomize`, mocking the settings store's `setGlobalShortcut`. -- Lock the store contract. +- [x] `src/features/onboarding/components/OnboardingOverlay.test.tsx` -- Add the capture-flow component tests (live preview, invalid warning, Save success/conflict, Cancel/Esc). -- Lock the overlay contract. + +**Acceptance Criteria:** + +- Given the onboarding overlay shows the default capture shortcut, when the user clicks "Customize", presses a valid modifier+key combination, and clicks Save with no conflict, then the new shortcut is registered and persisted via the shared Epic 7 path and the overlay continues showing the new shortcut as key caps. +- Given the user is in capture mode and saves a combination that fails to register (conflict), when the backend rejects it, then an inline warning is shown, the previously registered shortcut is retained, and the user can capture another combination without leaving onboarding. +- Given the user is in capture mode, when they press Esc or click Cancel, then capture is abandoned, the original shortcut is still displayed, and onboarding is not dismissed. +- Given the build, when the suites run, then `vitest` (updated onboarding store + overlay tests), `tsc`, and `npm run build` all pass; no backend, clippy, or binding changes are introduced. + +## Design Notes + +**Why frontend-only:** Conflict detection, register-before-commit, unregister-old, and atomic persistence already live in Epic 7's `commands::config::update_config`, surfaced to the UI by `useSettingsStore.setGlobalShortcut` (returns `true`/`false`, raises its own conflict toast). Story 8.3 is simply the onboarding-time entry point into that path — reusing it satisfies the epic's "share the validation/registration path" directive and adds no Rust. + +**Esc precedence during capture:** The capture keydown listener is registered in the capture phase and calls `stopPropagation`, so the overlay's bubble-phase Esc-dismiss never fires while customizing; the dismiss effects are additionally gated on `!customizing` so a backend `hotkey-pressed` event can't complete onboarding mid-capture. This mirrors `HotkeyCaptureField` exactly. + +**Capture core (golden, mirrors HotkeyCaptureField):** +```ts +if (isModifierCode(e.code)) return; // wait for a main key +const combo = formatShortcutFromEvent(e); +if (combo === null) { setCaptured(null); setWarning(USE_MODIFIER_MSG); return; } +setCaptured(combo); setWarning(null); // live preview; Save → applyCustomHotkey +``` + +## Verification + +**Commands:** + +- `npm test -- src/features/onboarding` -- expected: updated onboarding store + overlay tests pass (capture, save, conflict, cancel). +- `npm run build` -- expected: `tsc` + vite build succeed (no binding changes). +- `cd src-tauri && cargo test` -- expected: backend suite stays green and unchanged (no backend edits in this story). + +### Review Findings + +- [x] [Review][Patch] Capture-mode Save/Cancel keyboard activation was swallowed by shortcut capture [src/features/onboarding/components/OnboardingOverlay.tsx:123] — fixed by allowing focused button Enter/Space keydown events to pass through instead of treating them as shortcut input. +- [x] [Review][Patch] Save could be submitted repeatedly or followed by Cancel while registration was still pending [src/features/onboarding/components/OnboardingOverlay.tsx:191] — fixed with a ref-backed in-flight guard plus disabled Save/Cancel controls during registration. +- [x] [Review][Patch] A stale `hotkey-pressed` listener could still dismiss onboarding after capture started [src/features/onboarding/components/OnboardingOverlay.tsx:91] — fixed by checking listener activity and current onboarding state inside the callback before dismissing. + +#### Review Ledger (2026-06-17) + +- patch: Capture-mode Save/Cancel keyboard activation was swallowed by shortcut capture [src/features/onboarding/components/OnboardingOverlay.tsx:123] — focused capture controls now receive Enter/Space normally. +- patch: Save could be submitted repeatedly or followed by Cancel while registration was still pending [src/features/onboarding/components/OnboardingOverlay.tsx:191] — in-flight Save is guarded and controls are disabled until registration settles. +- patch: A stale `hotkey-pressed` listener could still dismiss onboarding after capture started [src/features/onboarding/components/OnboardingOverlay.tsx:91] — stale callbacks now check listener activity and current store state before dismissing. +- dismiss: Save failure can reject without showing the retry warning [src/features/onboarding/store.ts:98] — false positive; `useSettingsStore.setGlobalShortcut` catches thrown `updateConfig` errors and resolves `false`. diff --git a/_bmad-output/implementation-artifacts/spec-8-4-auto-start-on-login.md b/_bmad-output/implementation-artifacts/spec-8-4-auto-start-on-login.md new file mode 100644 index 0000000..2f40411 --- /dev/null +++ b/_bmad-output/implementation-artifacts/spec-8-4-auto-start-on-login.md @@ -0,0 +1,154 @@ +--- +title: "Story 8.4 — Auto-Start on Login" +type: "feature" +created: "2026-06-17" +status: "done" +baseline_commit: "7260382c80eb5caf2e58a7b084f3c613158b69d1" +context: + - "{project-root}/_bmad-output/implementation-artifacts/epic-8-context.md" + - "{project-root}/_bmad-output/project-context.md" +--- + + + +## Intent + +**Problem:** Notey has no way to start itself when the user logs in. Epic 8 ships only a red-phase scaffold (`services/autostart.rs` + `tests/autostart_tests.rs` + `Platform` trait `autostart_*` stubs, all `todo!`/`#[ignore]`); the auto-start plugin is not even a dependency, there is no config key, no IPC command, no UI affordance, and no ACL entries. A user cannot enable auto-start, and the app never relaunches after a reboot. (FR41–FR43.) + +**Approach:** Adopt `tauri-plugin-autostart` (v2.5.x) as the single OS mechanism, registered with `MacosLauncher::LaunchAgent`. Persist the user's preference as the new boolean `[general] auto_start` in the existing `config.toml` (the app's single config source of truth). Add two thin tauri-specta commands — `set_autostart(enabled)` (register/unregister via the plugin AND persist) and `get_autostart()` (live OS state) — surface a toggle in the Settings panel and a Command Palette action, and reconcile the OS to the persisted preference on every startup so a reboot relaunches the tray daemon. Add the required ACL permissions. + +## Boundaries & Constraints + +**Always:** +- OS registration goes through `tauri-plugin-autostart` only, via `app.autolaunch()` (`ManagerExt`): `enable()` / `disable()` / `is_enabled()`. Register the plugin with `MacosLauncher::LaunchAgent`. +- The persisted preference lives at `config.toml` `[general] auto_start` (serde key `autoStart`), a `bool` defaulting to `false`, on the existing `GeneralConfig` / `AppConfig`. It is the source of truth; on startup the OS state is reconciled to match it. +- `set_autostart` must do BOTH halves atomically under the existing `Mutex`: call the plugin to register/unregister, then persist the new value with `services::config::save` and update the in-memory config — mirroring `update_config`'s lock discipline. It returns the updated `AppConfig`. +- Both `set_autostart` and `get_autostart` are idempotent and guard plugin calls behind `#[cfg(desktop)]` (mirror `update_config`); map plugin errors to `NoteyError::Config`. +- All frontend IPC goes through generated tauri-specta bindings (`commands.setAutostart` / `commands.getAutostart` / `commands.getConfig`) — never raw `invoke`, never the plugin's JS package, no network, no broad FS. +- Capability ACL `default.json` must include `autostart:allow-enable`, `autostart:allow-disable`, `autostart:allow-is-enabled` (the plugin's commands, per AC) AND `allow-set-autostart`, `allow-get-autostart` (our commands). New `allow-*` commands are added to `EXPECTED_COMMANDS` in `tests/acl_tests.rs`, with autogenerated permission TOMLs created manually if the build skips them (known Tauri v2 gotcha). +- Re-enabling/disabling when already in that state is a no-op (check `is_enabled()` first). + +**Ask First:** +- Changing the persisted location away from `config.toml [general] auto_start` (e.g. back to a separate `autostart.toml`). +- Adding the `@tauri-apps/plugin-autostart` JS package or any other new runtime dependency beyond the Rust plugin crate. +- Implementing the `Platform` trait `autostart_*` methods as a second mechanism (they remain deferred — see Never). + +**Never:** +- Do NOT implement the `Platform` trait `autostart_enable/disable/is_enabled` methods as the mechanism for this story — the plugin is the single mechanism. Leave those stubs deferred to the Story 8.6 platform-abstraction capstone (only update their `todo!` text so they no longer claim Story 8.4). +- Do NOT introduce a second persistence file/section for auto-start; reuse `config.toml`. +- Do NOT add `auto_start` to `PartialGeneralConfig`/`merge_update` (avoids a `PartialGeneralConfig` ripple across existing settings update sites) — `set_autostart` sets the field directly under the lock. +- Do NOT call the plugin from non-desktop targets; do NOT add a new E2E journey (the first-run flow E2E is owned by the later cross-platform pass). +- Do NOT change `update_config`, the global-shortcut path, or any other unrelated config field. + +## I/O & Edge-Case Matrix + +| Scenario | Input / State | Expected Output / Behavior | Error Handling | +| --- | --- | --- | --- | +| Enable | `set_autostart(true)`, currently disabled | plugin `enable()`; `config.general.auto_start=true` saved; returns updated `AppConfig` | plugin error → `NoteyError::Config`, nothing persisted | +| Disable | `set_autostart(false)`, currently enabled | plugin `disable()`; `auto_start=false` saved; returns updated config | plugin error → `NoteyError::Config` | +| Enable when already on | `set_autostart(true)`, already enabled | no duplicate registration; `auto_start=true` persisted; success | N/A | +| Query live state | `get_autostart()` | returns `app.autolaunch().is_enabled()` | plugin error → `NoteyError::Config` | +| Fresh install | no `config.toml`, or `[general]` missing `autoStart` | `auto_start` defaults to `false`; auto-start off | missing key tolerated via serde default | +| Startup reconcile | `auto_start=true` but OS not registered (e.g. artifact removed) | startup best-effort `enable()` so reboot relaunches | failure logged, non-fatal — never blocks startup | +| Toggle in Settings | user clicks the auto-start toggle | `commands.setAutostart(!current)`; snapshot adopts returned config; toast on success | failure → error toast, displayed state unchanged | +| Palette toggle | "Toggle Auto-Start on Login" invoked | flips current state via the settings store (singleflight-guarded) | concurrent invokes coalesced | + + + +## Code Map + +- `src-tauri/Cargo.toml` -- add `tauri-plugin-autostart = "2"` (resolves to 2.5.x; match the existing caret-pin style of the other tauri plugins). +- `src-tauri/src/models/config.rs` -- add `#[serde(default)] pub auto_start: bool` to `GeneralConfig`; set `auto_start: false` in its `Default` impl. Generated bindings gain `GeneralConfig.autoStart: boolean`. +- `src-tauri/src/commands/autostart.rs` -- NEW. `set_autostart(app, config_state, config_dir_state, enabled: bool) -> Result` and `get_autostart(app) -> Result`. Thin handlers: plugin call under `#[cfg(desktop)]` + persist via `services::config::save` under the `Mutex` lock. `#[tauri::command] #[specta::specta]`. +- `src-tauri/src/commands/mod.rs` -- add `pub mod autostart;`. +- `src-tauri/src/lib.rs` -- (1) `.plugin(tauri_plugin_autostart::init(MacosLauncher::LaunchAgent, Some(vec![])))` in the builder chain; (2) add `commands::autostart::set_autostart` + `get_autostart` to `collect_commands!`; (3) in `setup`, after config load and before `app.manage(config)`, best-effort reconcile OS state to `config.general.auto_start` (`#[cfg(desktop)]`, non-fatal). +- `src-tauri/src/services/autostart.rs` -- DELETE (superseded: preference now lives in `config.toml`; OS handled by the plugin). Remove its line from `src-tauri/src/services/mod.rs`. +- `src-tauri/src/platform/{linux,macos,windows}.rs` -- update only the `autostart_*` `todo!` messages to reference Story 8.6 (plugin is the 8.4 mechanism); no behavior change. +- `src-tauri/capabilities/default.json` -- add the 5 permission identifiers listed in Always. +- `src-tauri/permissions/autogenerated/{set_autostart,get_autostart}.toml` -- create manually if `cargo build` doesn't generate them (project gotcha). +- `src-tauri/tests/acl_tests.rs` -- add `allow-set-autostart`, `allow-get-autostart` to `EXPECTED_COMMANDS`. +- `src-tauri/tests/autostart_tests.rs` -- rewrite to pin the config-backed `auto_start` persistence + idempotence contract via `services::config` + `models::config` (hermetic `TempDir`); remove `#[ignore]` and the obsolete `services::autostart` import. Platform launch-agent behavior stays QA-verified (keep that note). +- `src/features/settings/store.ts` -- add async `setAutostart(enabled: boolean)` (persist via `commands.setAutostart`, adopt returned config into snapshot, toast on success / revert+toast on failure); in `open()`, best-effort reconcile the toggle to `commands.getAutostart()`. +- `src/features/settings/components/SettingsPanel.tsx` -- add a General-section toggle row, `data-testid="autostart-toggle"`, `aria-pressed`, bound to `config.general.autoStart`, `onClick` → `setAutostart(!current)` (mirror the existing theme/layout row pattern). +- `src/features/command-palette/actions.ts` -- add `toggleAutostart()` (wrap in `singleflight('toggle-autostart', …)`, flip current state via the settings store). +- `src/features/command-palette/hooks/usePaletteCommands.ts` -- register a "Settings"-group command `{ id: 'toggle-autostart', label: 'Toggle Auto-Start on Login', action: toggleAutostart }`. +- Tests: `src/features/settings/store.test.ts`, `src/features/settings/components/SettingsPanel.test.tsx`, and the command-palette tests -- add coverage mirroring the existing theme-toggle cases (assert `set_autostart` invoked with `{ enabled }`, snapshot adoption, toast). Update `buildConfig` test factories to include `autoStart`. + +## Tasks & Acceptance + +**Execution:** + +- [x] `src-tauri/Cargo.toml` -- add the `tauri-plugin-autostart` dependency. +- [x] `src-tauri/src/models/config.rs` -- add `auto_start: bool` (serde default false) to `GeneralConfig` + `Default`; add/extend a unit test asserting the default is false and round-trips through TOML. +- [x] `src-tauri/src/commands/autostart.rs` + `commands/mod.rs` -- implement `set_autostart` + `get_autostart` (plugin + lock-disciplined persist), registered. +- [x] `src-tauri/src/lib.rs` -- register the plugin (LaunchAgent), wire both commands, add the non-fatal startup OS↔config reconcile. +- [x] `src-tauri/src/services/{autostart.rs,mod.rs}` -- delete the superseded scaffold service + its `mod` line. +- [x] `src-tauri/src/platform/{linux,macos,windows}.rs` -- retarget the `autostart_*` `todo!` messages to Story 8.6 (no behavior change). +- [x] `src-tauri/capabilities/default.json` + `permissions/autogenerated/*` + `tests/acl_tests.rs` -- add the 5 ACL identifiers, create permission TOMLs if needed, extend `EXPECTED_COMMANDS`. +- [x] `src-tauri/tests/autostart_tests.rs` -- rewrite to the config-backed persistence/idempotence contract; un-ignore. +- [x] `src/features/settings/store.ts` + `SettingsPanel.tsx` -- add `setAutostart` action + the toggle row + open() reconcile. +- [x] `src/features/command-palette/{actions.ts,hooks/usePaletteCommands.ts}` -- add the singleflight-guarded `toggleAutostart` action + palette entry. +- [x] Frontend tests -- add store + SettingsPanel + palette coverage; update `buildConfig` factories for `autoStart`. + +**Acceptance Criteria:** + +- Given the desktop app is running, when the user enables auto-start via the Settings toggle or the Command Palette action, then `tauri-plugin-autostart` registers the login launcher (LaunchAgent on macOS), `config.toml` persists `[general] auto_start = true`, and the toggle reflects the enabled state. +- Given auto-start is enabled, when the user disables it, then the plugin unregisters the launcher and `config.toml` persists `auto_start = false`. +- Given `auto_start = true` is persisted, when the app starts (e.g. after a reboot/login), then startup reconciles the OS registration to the preference (best-effort, non-fatal) so Notey relaunches as the tray daemon without user action. +- Given the capability ACL, when permissions are checked, then `autostart:allow-enable`, `autostart:allow-disable`, `autostart:allow-is-enabled`, `allow-set-autostart`, and `allow-get-autostart` are all present, and `acl_tests` passes. +- Given the build, when the suites run, then `cargo test` (incl. the un-ignored `autostart_tests` + `acl_tests`), `cargo clippy -- -D warnings`, `vitest`, `tsc`, and `npm run build` all pass with the regenerated bindings. + +### Review Findings + +- [x] [Review][Patch] `set_autostart` was not atomic on config save failure [src-tauri/src/commands/autostart.rs:50] — fixed by saving a cloned config first, committing the in-memory config only after save succeeds, and rolling back the OS registration best-effort when persistence fails. +- [x] [Review][Patch] Settings open reconciliation could overwrite a completed user toggle [src/features/settings/store.ts:128] — fixed by applying the live OS reconciliation only while the config snapshot still matches the one loaded by `open()`. +- [x] [Review][Patch] Palette toggle could flip stale persisted state instead of live OS state [src/features/command-palette/actions.ts:441] — fixed by querying `get_autostart` before toggling and falling back to persisted config only when the live query cannot return an `ok` result. +- [x] [Review][Patch] Generated bindings contained trailing whitespace [src/generated/bindings.ts:54] — fixed by tightening the Rust command rustdoc and regenerating bindings through the Rust export path. +- [x] [Review][Patch] Spec artifact had stray closing tags [_bmad-output/implementation-artifacts/spec-8-4-auto-start-on-login.md:134] — fixed by removing the malformed `` / `` suffix. +- [x] [Review][Patch] Hand-edited `auto_start` config spelling was not accepted [src-tauri/src/models/config.rs:55] — fixed by accepting `auto_start` as a serde alias while preserving the existing generated `autoStart` IPC/config shape. + +#### Review Ledger (2026-06-17) + +- patched: `set_autostart` was not atomic on config save failure [src-tauri/src/commands/autostart.rs:50] — save now commits through a cloned config and rolls back OS registration best-effort on persistence failure. +- patched: Settings open reconciliation could overwrite a completed user toggle [src/features/settings/store.ts:128] — stale live-state responses are ignored once the loaded config snapshot has been replaced. +- patched: Palette toggle could flip stale persisted state instead of live OS state [src/features/command-palette/actions.ts:441] — action now uses live OS state when available. +- patched: Generated bindings contained trailing whitespace [src/generated/bindings.ts:54] — rustdoc/generation path now produces a whitespace-clean diff. +- patched: Spec artifact had stray closing tags [_bmad-output/implementation-artifacts/spec-8-4-auto-start-on-login.md:134] — malformed suffix removed. +- patched: Hand-edited `auto_start` config spelling was not accepted [src-tauri/src/models/config.rs:55] — `auto_start` is accepted as a deserialize alias while `autoStart` remains the emitted/generated key per the spec's serde-key/code-map notes and existing project convention. +- dismissed: Missing backend command module [src-tauri/src/commands/mod.rs:2] — false positive from reviewing tracked diff only; automation diff includes untracked `src-tauri/src/commands/autostart.rs`. +- dismissed: Raw autostart plugin commands bypass persisted config source of truth [src-tauri/capabilities/default.json:14] — frozen acceptance criteria explicitly require the three `autostart:allow-*` plugin ACL permissions in addition to the mediated custom commands. +- dismissed: Persisted TOML key is `autoStart`, not literal `auto_start` [src-tauri/src/models/config.rs:55] — frozen spec also names `autoStart` as the serde key and generated binding shape; alias support was added for hand-edited `auto_start` configs. + +## Design Notes + +**Why the plugin, not the `Platform` trait:** Story 8.4's frozen AC mandates `tauri-plugin-autostart` configured with `MacosLauncher::LaunchAgent` and the `autostart:allow-*` ACL entries — i.e. the plugin IS the contract. The plugin needs an `AppHandle` (`app.autolaunch()`), which the object-safe `Platform` trait (constructed by `platform::current()` with no app) cannot provide, and its `autostart_*` stubs are labeled for the Story 8.6 platform capstone. Using the plugin avoids a redundant second mechanism (the plugin already wraps the per-OS `.desktop`/LaunchAgent/registry logic the stubs described). + +**Why `config.toml [general] auto_start`, deleting `services/autostart.rs`:** The AC literally specifies `config.toml: [general] auto_start`. The scaffold's separate `autostart.toml`/`AutostartState` existed only to dodge a feared `GeneralConfig` ripple during the red phase, and its module doc explicitly says "reconcile the section name at green phase." Reconciling to the one config source removes a redundant file and keeps a single source of truth. Adding the field directly in `set_autostart` (not via `PartialGeneralConfig`) keeps the change off the shared partial-update path, so existing `update_config` partial literals are untouched. + +**Command shape (mirror `update_config`'s lock discipline):** +```rust +let mut cfg = config_state.lock().unwrap_or_else(recover_poisoned_config); +#[cfg(desktop)] { + use tauri_plugin_autostart::ManagerExt; + let mgr = app.autolaunch(); + if enabled != mgr.is_enabled().map_err(cfg_err)? { + if enabled { mgr.enable() } else { mgr.disable() }.map_err(cfg_err)?; + } +} +cfg.general.auto_start = enabled; +services::config::save(&config_dir_state.0, &cfg)?; // persist after a successful OS change +Ok(cfg.clone()) +``` + +## Verification + +**Commands:** + +- `cd src-tauri && cargo test` -- expected: all suites green, including the un-ignored `autostart_tests` and the extended `acl_tests`. +- `cd src-tauri && cargo clippy --all-targets -- -D warnings` -- expected: clean. +- `npm test -- src/features/settings src/features/command-palette` -- expected: new auto-start store/panel/palette tests pass. +- `npm run build` -- expected: tauri-specta regenerates `src/generated/bindings.ts` with `setAutostart`/`getAutostart`/`GeneralConfig.autoStart`; `tsc` + vite build succeed. + +**Manual checks (if no CLI):** + +- Platform launch-agent behavior (does the OS actually relaunch the app at login?) is QA-verified per `autostart_tests.rs`'s module note — not covered by automated tests. diff --git a/_bmad-output/implementation-artifacts/spec-8-5-per-user-data-isolation.md b/_bmad-output/implementation-artifacts/spec-8-5-per-user-data-isolation.md new file mode 100644 index 0000000..14054d6 --- /dev/null +++ b/_bmad-output/implementation-artifacts/spec-8-5-per-user-data-isolation.md @@ -0,0 +1,131 @@ +--- +title: "Story 8.5 — Per-User Data Isolation" +type: "feature" +created: "2026-06-17" +status: "done" +baseline_commit: "9572e56f7387003c4bae20e4b2d1143cf27e31a2" +context: + - "{project-root}/_bmad-output/implementation-artifacts/epic-8-context.md" + - "{project-root}/_bmad-output/project-context.md" +--- + + + +## Intent + +**Problem:** Per-user isolation is partly real but not yet routed through the `Platform` abstraction the epic mandates as the single source of truth (FR51/FR58). The SQLite database path is resolved by Tauri's opaque `app.path().app_data_dir()` (bundle id `com.pinkyd.tauri-app`) rather than a per-user platform-standard dir, and the `Platform` trait's `data_dir()` and `socket_path()` are red-phase `todo!()` stubs labeled "Story 8.5". The socket path/0600 logic already works but lives inline in `ipc/socket_server.rs`, so there is no single owner of path resolution. The Story 8.5 acceptance tests in `tests/platform_tests.rs` are `#[ignore]`. + +**Approach:** Implement `Platform::data_dir()` and `Platform::socket_path()` for all three OS targets so data and socket paths resolve from the current user's platform-standard directories (`dirs` crate: `data_dir()` + namespace; `runtime_dir()`/temp for the socket). Route the database location through `platform::current().data_dir()` and make `socket_server::socket_path()` delegate its default-case resolution to `platform::current().socket_path()` (keeping its existing `--socket-path` / `NOTEY_SOCKET_PATH` override seams). Add a `NOTEY_DATA_DIR` test/override seam to `data_dir()` mirroring the existing socket seam. Un-ignore the two Story 8.5 platform tests. + +## Boundaries & Constraints + +**Always:** +- Path resolution is namespaced per existing convention: `notey` on Linux/Windows, `com.notey.app` on macOS (mirrors `services::config::config_dir`). Data dir = `dirs::data_dir()` + namespace (XDG_DATA_HOME / %APPDATA% / `~/Library/Application Support`). +- `data_dir()` honors a `NOTEY_DATA_DIR` env override first (test/hermetic seam, mirrors `NOTEY_SOCKET_PATH`), then falls back to the platform-standard path; it returns `Err(NoteyError::Config(...))` when no directory can be determined. It is a pure resolver — it does NOT create the directory (the caller `db::init_db` already `create_dir_all`s). +- `Platform::socket_path()` returns the pure default user-scoped path (Unix: `dirs::runtime_dir()/notey.sock`, else user-scoped temp fallback; Windows: user-scoped namespaced pipe). The default-resolution body + the `user_scope_token()` helper move OUT of `socket_server.rs` and INTO `platform` so there is one implementation. +- `socket_server::socket_path()` keeps its override precedence — `--socket-path` arg, then `NOTEY_SOCKET_PATH` env — then delegates the default to `platform::current().socket_path()`. Behavior for both seams and the default must be byte-identical to today. +- The socket file is still created owner-only (0600 on Unix) by the existing `set_owner_only()` in `socket_server.rs` — do not change that mechanism. +- Only `data_dir()` and `socket_path()` are implemented this story. `config_dir()`, `log_dir()`, `register_hotkey()`, and the `autostart_*` trait methods remain Story 8.6 `todo!()` stubs. +- All dirs come from the already-present `dirs` crate (v5) — no new dependency. + +**Ask First:** +- Changing the live config-resolution path (`services::config::config_dir`) or implementing the trait `config_dir()` — that is Story 8.6's mechanism; config is already user-scoped. +- Adding a `--data-dir` CLI argument (full E2E-hermetic data isolation, DW-91/DW-95) — the `NOTEY_DATA_DIR` env seam is the agreed scope here. +- Migrating an existing `com.pinkyd.tauri-app` database to the new `notey` data dir (greenfield pre-v1; no migration intended). + +**Never:** +- Do NOT change the `notey-cli` crate's `client.rs` socket-path logic — its duplication of the resolution is intentional (standalone crate, no workspace) and already tested to mirror the server. Verify it still matches after relocation; do not unify it. +- Do NOT add an auth token or any isolation mechanism beyond the user-scoped path + 0600 file mode (v1 contract). +- Do NOT touch hotkey, autostart, accessibility, FTS, or any unrelated subsystem. +- Do NOT change the socket override seams' precedence or the 0600 logic. +- No new IPC commands, no frontend changes, no new E2E journey. + +## I/O & Edge-Case Matrix + +| Scenario | Input / State | Expected Output / Behavior | Error Handling | +| --- | --- | --- | --- | +| Linux data dir | `NOTEY_DATA_DIR` unset | `data_dir()` = `dirs::data_dir()/notey` (`$XDG_DATA_HOME` or `~/.local/share`) | dirs None → `NoteyError::Config` | +| macOS data dir | `NOTEY_DATA_DIR` unset | `data_dir()` = `~/Library/Application Support/com.notey.app` | dirs None → `NoteyError::Config` | +| Windows data dir | `NOTEY_DATA_DIR` unset | `data_dir()` = `%APPDATA%\notey` | dirs None → `NoteyError::Config` | +| Data dir override | `NOTEY_DATA_DIR=/tmp/x` | `data_dir()` = `/tmp/x` (verbatim) | N/A | +| Unix socket default | no override, `XDG_RUNTIME_DIR` set | `socket_path()` = `$XDG_RUNTIME_DIR/notey.sock` | N/A | +| Unix socket fallback | no `XDG_RUNTIME_DIR` | `socket_path()` = `tempdir/notey-.sock` (token from HOME/USER) | empty token → `notey.sock` | +| Windows socket | any | `socket_path()` = namespaced pipe `notey-` | empty token → `notey` | +| Socket override (server) | `NOTEY_SOCKET_PATH` / `--socket-path` set | `socket_server::socket_path()` returns the override (unchanged) | N/A | +| Server default == platform | no override | `socket_server::socket_path()` == `platform::current().socket_path()` | N/A | +| DB init | app startup | DB opened at `platform::current().data_dir()/notey.db`; dir created if missing | resolve error → startup fails fast (expect) | + + + +## Code Map + +- `src-tauri/src/platform/mod.rs` -- add `pub(crate)` helpers: `resolve_data_dir(namespace: &str) -> Result` (honors `NOTEY_DATA_DIR`, else `dirs::data_dir().join(namespace)`, else `Err(Config)`); `#[cfg(unix)] resolve_unix_socket() -> PathBuf` and `#[cfg(windows)] resolve_windows_socket() -> PathBuf` (relocated default resolution); `user_scope_token() -> Option` (moved verbatim from `socket_server.rs`). Update the module-doc green-phase note to reflect that 8.5 implements `data_dir`+`socket_path` and routes the DB + socket through the trait (config_dir/log_dir stay 8.6). +- `src-tauri/src/platform/linux.rs` -- `data_dir()` → `super::resolve_data_dir("notey")`; `socket_path()` → `super::resolve_unix_socket()`. Drop the two `todo!()`. +- `src-tauri/src/platform/macos.rs` -- `data_dir()` → `super::resolve_data_dir("com.notey.app")`; `socket_path()` → `super::resolve_unix_socket()`. Drop the two `todo!()`. +- `src-tauri/src/platform/windows.rs` -- `data_dir()` → `super::resolve_data_dir("notey")`; `socket_path()` → `super::resolve_windows_socket()`. Drop the two `todo!()`. +- `src-tauri/src/ipc/socket_server.rs` -- `socket_path()`: keep arg + env override checks, then `return crate::platform::current().socket_path();`. Remove the relocated inline unix/windows blocks and the local `user_scope_token()`. Clean up now-unused imports (`dirs`, possibly `Path`) to satisfy `clippy -D warnings`. +- `src-tauri/src/lib.rs` -- in `setup`, replace `app.path().app_data_dir()` (lines ~176-179) with `crate::platform::current().data_dir().expect("Failed to resolve data dir")`; drop the now-unused `app.path()` call there. Confirm `tauri::Manager`/`app.path()` is still needed elsewhere before removing any import. +- `src-tauri/tests/platform_tests.rs` -- remove `#[ignore]` from `data_dir_is_user_scoped_and_standard` and `socket_path_is_user_scoped` (the two Story 8.5 tests). Add `data_dir_honors_override_seam` (set/restore `NOTEY_DATA_DIR` under a mutex, assert verbatim passthrough) and, where cheap, a macOS-gated assertion that the data dir contains `com.notey.app`. Leave the 8.6-labeled tests `#[ignore]`. +- `src-tauri/tests/ipc_tests.rs` -- add `socket_server_default_matches_platform` asserting `socket_server::socket_path() == platform::current().socket_path()` with no overrides set (under the existing `SOCKET_PATH_ENV_LOCK`). Existing `int_002_*` socket tests must still pass unchanged. + +## Tasks & Acceptance + +**Execution:** + +- [x] `src-tauri/src/platform/mod.rs` -- add `resolve_data_dir`, `resolve_unix_socket`/`resolve_windows_socket`, and the moved `user_scope_token`; update the module-doc note. +- [x] `src-tauri/src/platform/{linux,macos,windows}.rs` -- implement `data_dir()` and `socket_path()` via the mod helpers; remove the two Story-8.5 `todo!()` per file. +- [x] `src-tauri/src/ipc/socket_server.rs` -- make `socket_path()` delegate the default to `platform::current().socket_path()`; remove relocated logic + dead imports. +- [x] `src-tauri/src/lib.rs` -- resolve the DB dir via `platform::current().data_dir()`; remove the dead `app_data_dir()` path. +- [x] `src-tauri/tests/platform_tests.rs` -- un-ignore the two Story 8.5 tests; add the override-seam test (+ macOS naming assertion). +- [x] `src-tauri/tests/ipc_tests.rs` -- add the server-default-matches-platform invariant test. +- [x] Grep for other readers of `app_data_dir`/the old data path and the relocated socket helpers; fix any stragglers so the single-source-of-truth holds (only `db::init_db` param + `lib.rs` startup; both rewired). + +### Review Findings + +- [x] [Review][Patch] Make env-sensitive path tests hermetic and XDG-compliant [src-tauri/tests/platform_tests.rs:65] — applied: `data_dir_is_user_scoped_and_standard` now asserts `platform::current().data_dir()` equals `dirs::data_dir().join(namespace)` instead of assuming Unix data dirs are under `$HOME`; `NOTEY_DATA_DIR` and `NOTEY_SOCKET_PATH` tests now restore prior env values with an `OsString` guard. + +#### Review Ledger (2026-06-17) + +- patch: Make env-sensitive path tests hermetic and XDG-compliant [src-tauri/tests/platform_tests.rs:65; src-tauri/tests/ipc_tests.rs:38] — fixed valid XDG_DATA_HOME-outside-HOME failures and non-Unicode prior-env restoration leaks in tests. +- dismiss: Change production `NOTEY_DATA_DIR` to `var_os` / ignore empty values [src-tauri/src/platform/mod.rs:118] — dismissed because the story explicitly mirrors the existing `NOTEY_SOCKET_PATH` string env seam and preserves override behavior; empty string remains a verbatim override. + +**Acceptance Criteria:** + +- Given the app resolves data paths, when the database path is determined, then it is `platform::current().data_dir()/notey.db` under the current user's platform-standard data directory (XDG_DATA_HOME / %APPDATA% / `~/Library/Application Support`), with no system-wide shared directory used. (FR51/FR58) +- Given the IPC socket path is resolved with no override set, when `socket_server::socket_path()` and `platform::current().socket_path()` are compared, then they are equal and (on Linux with `XDG_RUNTIME_DIR` set) live under that per-user runtime dir as `notey.sock`, and the created socket file is mode 0600. (FR51) +- Given the `NOTEY_DATA_DIR` / `NOTEY_SOCKET_PATH` override seams, when each is set, then `data_dir()` / `socket_server::socket_path()` return the override verbatim (the existing socket-arg/env precedence is preserved). +- Given two users on one machine, when both run Notey, then each resolves an independent database, config, and IPC socket from their own per-user directories and neither can reach the other's 0600 socket (automatable slice: paths derive from per-user `dirs`/runtime dirs; true multi-uid access stays manual QA per RISK-E6-007). +- Given the build, when the suites run, then `cargo test` (incl. the un-ignored `platform_tests` Story 8.5 cases and the existing `ipc_tests` socket cases), `cargo clippy --all-targets -- -D warnings`, `vitest`, `tsc`, and `npm run build` all pass. + +## Design Notes + +**Single source of truth.** The epic mandates that data/config/log/socket resolution funnel through the `Platform` trait. This story does the two methods labeled 8.5 (`data_dir`, `socket_path`) and rewires their two callers (`lib.rs` DB init, `socket_server::socket_path`). `config_dir()`/`log_dir()` and hotkey/autostart routing stay Story 8.6 stubs — the live config path (`services::config::config_dir`) is already user-scoped, so config isolation (AC3) holds today without touching 8.6. + +**Why relocate the socket logic instead of duplicating.** Putting the default resolution in `platform` and having `socket_server` delegate keeps one implementation inside the app crate. The override seams (`--socket-path`, `NOTEY_SOCKET_PATH`) are process-level concerns and stay in `socket_server`; the E2E harness depends on them (it routes `--socket-path` via `tauri:options.args` because a modern WebKitWebDriver resets the app env — see DW-95). The `notey-cli` crate keeps its own mirror copy (standalone, no workspace); it must continue to match the relocated default. + +**Shared resolver shape (platform/mod.rs):** +```rust +pub(crate) fn resolve_data_dir(namespace: &str) -> Result { + if let Ok(custom) = std::env::var("NOTEY_DATA_DIR") { + return Ok(PathBuf::from(custom)); + } + dirs::data_dir() + .map(|base| base.join(namespace)) + .ok_or_else(|| NoteyError::Config("Could not determine platform data directory".into())) +} +``` + +## Verification + +**Commands:** + +- `cd src-tauri && cargo test` -- expected: all suites green, including the un-ignored `platform_tests` Story 8.5 cases, the new override/invariant tests, and the existing `ipc_tests` socket cases. +- `cd src-tauri && cargo test --test platform_tests` -- expected: the two Story 8.5 tests (`data_dir_is_user_scoped_and_standard`, `socket_path_is_user_scoped`) now run and pass; the remaining Story 8.6 `todo!()` tests stay `#[ignore]`d (4 passed, 3 ignored). +- `cd src-tauri && cargo clippy --all-targets -- -D warnings` -- expected: clean (no dead-import warnings after the socket_server/lib.rs edits). +- `npm run build` -- expected: bindings regenerate unchanged (no IPC surface change); `tsc` + vite build succeed. + +**Manual checks (if no CLI):** + +- True multi-uid cross-user socket/data inaccessibility is platform QA (RISK-E6-007); the automated tests pin only the per-user path derivation + 0600 file mode. + + diff --git a/_bmad-output/implementation-artifacts/spec-8-6-cross-platform-verification-wayland-fallback.md b/_bmad-output/implementation-artifacts/spec-8-6-cross-platform-verification-wayland-fallback.md new file mode 100644 index 0000000..44c20a7 --- /dev/null +++ b/_bmad-output/implementation-artifacts/spec-8-6-cross-platform-verification-wayland-fallback.md @@ -0,0 +1,138 @@ +--- +title: "Story 8.6 — Cross-Platform Verification & Wayland Fallback (Platform trait completion)" +type: "feature" +created: "2026-06-17" +status: "done" +baseline_commit: "1b1716644ceecd58095b0990fb15e09ec3fd6664" +context: + - "{project-root}/_bmad-output/implementation-artifacts/epic-8-context.md" + - "{project-root}/_bmad-output/project-context.md" +--- + + + +## Intent + +**Problem:** The `Platform` trait is meant to be the single source of truth for all OS-divergent behavior (epic-8 capstone, FR56/FR57/FR58), but three contracts are still red-phase `todo!()` for every OS: `config_dir()`, `log_dir()`, and `register_hotkey()`. Config paths today resolve through a separate `services::config::config_dir()` (a second implementation), there is no platform log-dir resolver at all, and nothing routes the global-hotkey backend through the trait — so the Wayland gap (FR57) has no single place to detect and degrade gracefully. Three platform acceptance tests are `#[ignore]`. + +**Approach:** Implement `config_dir()`, `log_dir()`, and `register_hotkey()` for all three OS targets via the trait. Make `services::config::config_dir()` delegate to `platform::current().config_dir()` so config-path resolution has one implementation. Implement `register_hotkey()` as a Wayland-aware backend selector (X11/XWayland/macOS/Windows → `Standard`; pure-Wayland-without-XWayland → `Err`, since native portal support is the post-v1 fast-follow per the PRD), and have `lib.rs` consult it so a compositor with no working backend is detected and logged (graceful degradation; window stays summonable via tray). Un-ignore the two now-satisfiable platform tests. + +## Boundaries & Constraints + +**Always:** +- Path namespaces match the existing convention (`services::config::config_dir`): `notey` on Linux/Windows, `com.notey.app` on macOS. +- `config_dir()` = `dirs::config_dir()/` (`$XDG_CONFIG_HOME` / `%APPDATA%` / `~/Library/Application Support`). `log_dir()` per-OS standard: Linux `dirs::state_dir()/notey/logs` (`$XDG_STATE_HOME`), macOS `~/Library/Logs/com.notey.app`, Windows `dirs::data_local_dir()/notey/logs` (`%LOCALAPPDATA%`). Both are pure resolvers — they do NOT create the directory — and return `Err(NoteyError::Config(..))` when the base dir cannot be determined. +- `services::config::config_dir()` keeps its signature and returns the same path it returns today; it now obtains that path from `platform::current().config_dir()`. The byte-for-byte result must be unchanged. +- `register_hotkey(accelerator)` returns `Ok(HotkeyBackend::Standard)` on macOS, Windows, and any Linux session where the X11 path is usable (X11 native, or Wayland with XWayland — i.e. `DISPLAY` is set). It returns `Err(NoteyError::Config(..))` only on a pure-Wayland session with no XWayland (`XDG_SESSION_TYPE=wayland`/`WAYLAND_DISPLAY` set AND `DISPLAY` unset). It never panics and never requires a Tauri `AppHandle`. +- `lib.rs` consults `platform::current().register_hotkey(&shortcut_str)` in the desktop global-shortcut setup: on `Ok(_)` it performs the existing plugin registration exactly as today; on `Err(e)` it logs a clear FR57 degradation warning (global shortcut unavailable on this compositor; summon via tray) and skips the initial `register()` call. The plugin builder/handler install stays unconditional so re-registration via `update_config` still works. +- All path/dir resolution uses the already-present `dirs` crate (v5) — no new dependency. + +**Ask First:** +- Adding a real `ashpd` D-Bus GlobalShortcuts portal registration (the native Wayland path) — that is the post-v1 fast-follow tracked in DW-96, gated on Tauri global-hotkey PR #162. +- Implementing the `autostart_*` trait methods or any user-facing (toast/dialog) notification UI — tracked in DW-97 / DW-99. +- Introducing a logging plugin or any consumer of `log_dir()` — this story only adds the resolver to satisfy the trait contract. + +**Never:** +- Do NOT change `services::config::config_dir`'s public signature, the `notey`/`com.notey.app` namespaces, or any persisted path. No data/config migration. +- Do NOT implement the `autostart_*` methods (leave them as `todo!()` relabeled to DW-97) or the `accessibility_*`/`data_dir`/`socket_path` methods (already done in Stories 8.2/8.5). +- Do NOT change the existing fail-soft behavior of hotkey registration for the `Standard` backend, or touch the conflict-detection / `update_config` re-registration path. +- Do NOT add new IPC commands, frontend changes, new E2E journeys, or new env-override seams. +- Do NOT modify the CI workflow / release pipeline (AC4 release artifacts → DW-98). + +## I/O & Edge-Case Matrix + +| Scenario | Input / State | Expected Output / Behavior | Error Handling | +| --- | --- | --- | --- | +| Linux config dir | unset env | `config_dir()` = `dirs::config_dir()/notey` | dirs None → `NoteyError::Config` | +| macOS config dir | unset env | `config_dir()` = `~/Library/Application Support/com.notey.app` | dirs None → `NoteyError::Config` | +| Windows config dir | unset env | `config_dir()` = `%APPDATA%\notey` | dirs None → `NoteyError::Config` | +| Linux log dir | unset env | `log_dir()` = `dirs::state_dir()/notey/logs` | dirs None → `NoteyError::Config` | +| macOS log dir | unset env | `log_dir()` = `~/Library/Logs/com.notey.app` | home None → `NoteyError::Config` | +| Windows log dir | unset env | `log_dir()` = `%LOCALAPPDATA%\notey\logs` | dirs None → `NoteyError::Config` | +| Hotkey on macOS/Windows | any | `register_hotkey()` = `Ok(Standard)` | N/A | +| Hotkey on X11 / XWayland | `DISPLAY` set | `register_hotkey()` = `Ok(Standard)` | N/A | +| Hotkey headless (cargo test) | no `DISPLAY`, no wayland vars | `register_hotkey()` = `Ok(Standard)` | N/A | +| Hotkey pure Wayland | wayland session, `DISPLAY` unset | `register_hotkey()` = `Err(Config)` | caller logs FR57 warning, skips register | +| config single-source | any | `platform::current().config_dir()` == `services::config::config_dir()` | both propagate the same `Err` | + + + +## Code Map + +- `src-tauri/src/platform/mod.rs` -- add `pub(crate) fn resolve_config_dir(namespace: &str) -> Result` (mirrors `resolve_data_dir`, no env seam). Update the module-doc green-phase note: 8.6 implements `config_dir`/`log_dir`/`register_hotkey`; `autostart_*` deferred to DW-97; native Wayland portal deferred to DW-96. +- `src-tauri/src/platform/linux.rs` -- `config_dir()` → `super::resolve_config_dir("notey")`; `log_dir()` → `dirs::state_dir()/notey/logs` (Err if None); `register_hotkey()` → Wayland-aware backend selection (see Design Notes). Drop the three `todo!()`; relabel the `autostart_*` `todo!()` to DW-97. +- `src-tauri/src/platform/macos.rs` -- `config_dir()` → `super::resolve_config_dir("com.notey.app")`; `log_dir()` → `dirs::home_dir()/Library/Logs/com.notey.app` (Err if None); `register_hotkey()` → `Ok(Standard)`. Drop the three `todo!()`; relabel `autostart_*` to DW-97. +- `src-tauri/src/platform/windows.rs` -- `config_dir()` → `super::resolve_config_dir("notey")`; `log_dir()` → `dirs::data_local_dir()/notey/logs` (Err if None); `register_hotkey()` → `Ok(Standard)`. Drop the three `todo!()`; relabel `autostart_*` to DW-97. +- `src-tauri/src/services/config.rs` -- `config_dir()` body becomes `crate::platform::current().config_dir()`; keep the doc comment and signature. Remove the now-dead `dirs`/`cfg` namespace logic and any import left unused. +- `src-tauri/src/lib.rs` -- in the `#[cfg(desktop)]` global-shortcut block, call `platform::current().register_hotkey(&shortcut_str)`; on `Ok(_)` keep the existing register flow, on `Err(e)` log the FR57 warning and skip the initial `register()`. Plugin builder install stays unconditional. +- `src-tauri/tests/platform_tests.rs` -- un-ignore `current_resolves_to_target_platform` and `linux_hotkey_uses_standard_backend_on_x11`; keep `linux_hotkey_falls_back_to_wayland_portal` ignored. Add `config_dir_is_user_scoped_and_standard`, `log_dir_is_user_scoped_and_standard`, a non-Linux `hotkey_uses_standard_backend`, and `config_dir_matches_services_config` (single-source invariant). + +## Tasks & Acceptance + +**Execution:** + +- [x] `src-tauri/src/platform/mod.rs` -- add `resolve_config_dir`; update module-doc note. +- [x] `src-tauri/src/platform/{linux,macos,windows}.rs` -- implement `config_dir()`, `log_dir()`, `register_hotkey()`; remove their `todo!()`; relabel `autostart_*` stubs to DW-97. +- [x] `src-tauri/src/services/config.rs` -- delegate `config_dir()` to `platform::current().config_dir()`; drop dead code/imports. +- [x] `src-tauri/src/lib.rs` -- consult `register_hotkey()` in the desktop shortcut setup; log FR57 warning + skip `register()` on `Err`. +- [x] `src-tauri/tests/platform_tests.rs` -- un-ignore the two satisfiable tests; add the config/log/hotkey/single-source tests (hermetic, `#[cfg(target_os)]`-gated where the expected path differs). +- [x] Grep for other readers of the trait stubs / `services::config::config_dir` to confirm the single-source-of-truth holds and nothing still depends on the removed code. + +**Acceptance Criteria:** + +- Given the `Platform` trait, when the app runs on each target OS, then `config_dir()`, `log_dir()`, `register_hotkey()`, `data_dir()`, and `socket_path()` all resolve without any `todo!()`/panic, and `#[cfg(target_os)]` implementations exist in `platform/{linux,macos,windows}.rs`. (AC1) +- Given config-path resolution, when `services::config::config_dir()` and `platform::current().config_dir()` are compared, then they return the identical path (single source of truth), under the per-user platform-standard config dir with no system-wide shared directory. (FR58) +- Given a Linux session where the X11 path is usable (X11 native or XWayland present, including headless `cargo test`), when `register_hotkey()` is called, then it returns `Ok(HotkeyBackend::Standard)`; given a pure-Wayland session with no XWayland, then it returns `Err` and `lib.rs` logs that the global shortcut is unavailable on the compositor while leaving the window summonable via the tray. (FR56/FR57) +- Given the existing `Standard` backend path, when the app registers the global shortcut at startup, then behavior is unchanged from before this story (fail-soft on conflict; re-registration via `update_config` still works). +- Given the build, when the suites run, then `cargo test` (incl. the un-ignored `platform_tests` cases and the new config/log/hotkey/single-source tests), `cargo clippy --all-targets -- -D warnings`, `vitest`, `tsc`, and `npm run build` all pass. + +## Design Notes + +**Single source of truth.** `services::config::config_dir()` and the trait `config_dir()` currently duplicate `dirs::config_dir() + namespace`. Collapsing the live function onto the trait (rather than vice-versa) keeps the trait authoritative — the epic's stated design — without changing any caller's signature. The 8.5 spec explicitly flagged this as "Story 8.6's mechanism." + +**Linux hotkey backend selection (no AppHandle needed).** The trait method only *selects/validates* the backend; the actual Tauri plugin registration stays in `lib.rs` where the `AppHandle` lives. Selection rule: +```rust +// linux.rs register_hotkey +let wayland = std::env::var_os("WAYLAND_DISPLAY").is_some() + || std::env::var("XDG_SESSION_TYPE").map(|t| t == "wayland").unwrap_or(false); +let xwayland = std::env::var_os("DISPLAY").is_some(); +if wayland && !xwayland { + return Err(NoteyError::Config( + "global shortcut unavailable: Wayland compositor without XWayland \ + (native portal support is a fast-follow — DW-96)".into(), + )); +} +Ok(HotkeyBackend::Standard) +``` +This makes the headless CI `cargo test` (no env vars set) return `Standard`, satisfying `linux_hotkey_uses_standard_backend_on_x11`, while honoring the v1 contract that XWayland is the baseline fallback. The `linux_hotkey_falls_back_to_wayland_portal` test stays `#[ignore]` (it expects `Ok(WaylandPortal)`, which only the DW-96 portal work will deliver). + +**Why autostart stays a stub.** The `autostart_*` trait methods take `&self` with no `AppHandle`, but `tauri-plugin-autostart` (the mechanism that already satisfies FR41–43 in Story 8.4) needs the handle. Routing through the trait would mean hand-rolling plist/.desktop/registry logic — a no-gain, high-risk refactor. Tracked in DW-97; the `todo!()` bodies are relabeled, not removed (AC1 requires the trait to *define* them, and nothing calls them). + +## Verification + +**Commands:** + +- `cd src-tauri && cargo test` -- expected: all suites green, including the un-ignored `platform_tests` cases (`current_resolves_to_target_platform`, `linux_hotkey_uses_standard_backend_on_x11`) and the new config/log/hotkey/single-source tests; `linux_hotkey_falls_back_to_wayland_portal` stays ignored. +- `cd src-tauri && cargo clippy --all-targets -- -D warnings` -- expected: clean (no dead-import/dead-code warnings after the `services::config` and `lib.rs` edits). +- `npm run build` -- expected: bindings regenerate unchanged (no IPC surface change); `tsc` + vite build succeed. + +**Manual checks (if no CLI):** + +- Real pure-Wayland-without-XWayland degradation and native portal behavior are platform QA (RISK-001 / DW-96); the automated tests pin only the per-OS path derivation and the X11/headless `Standard` backend selection. + +### Review Findings + +- [x] [Review][Patch] Platform docs still contradicted the frozen Wayland contract [src-tauri/src/platform/mod.rs:1] — patched: removed stale red-phase and native-portal-now guidance, and updated the trait docs to describe Standard vs pure-Wayland-unavailable behavior with DW-96 deferred. +- [x] [Review][Patch] Linux hotkey test was not hermetic for X11/XWayland [src-tauri/tests/platform_tests.rs:203] — patched: serialized hotkey env mutation and made the X11 test set `DISPLAY`, clear `WAYLAND_DISPLAY`, and set `XDG_SESSION_TYPE=x11`. +- [x] [Review][Patch] Empty `DISPLAY` counted as XWayland support [src-tauri/src/platform/linux.rs:66] — patched: display env vars are now treated as present only when non-empty. +- [x] [Review][Patch] Pure-Wayland unavailable path lacked an active regression test [src-tauri/tests/platform_tests.rs:210] — patched: added an active pure-Wayland-with-empty-`DISPLAY` test that expects a graceful `Config` error. + +#### Review Ledger (2026-06-17) + +- patch: Platform docs still contradicted the frozen Wayland contract [src-tauri/src/platform/mod.rs:1] — stale red-phase/portal-now docs contradicted the approved DW-96 deferral; patched. +- dismiss: Startup-only backend gate leaves rebind path inconsistent [src-tauri/src/commands/config.rs:109] — approved spec explicitly preserves `update_config` re-registration behavior and forbids touching that path in this story; registration failure remains fail-soft before persistence. +- dismiss: User notification is only stderr logging [src-tauri/src/lib.rs:309] — approved story scope requires a clear FR57 warning log and defers user-facing UI to DW-99. +- patch: Empty `DISPLAY` incorrectly counted as XWayland support [src-tauri/src/platform/linux.rs:66] — empty env vars are a real edge case; patched. +- dismiss: Autostart trait methods still panic in production paths [src-tauri/src/platform/linux.rs:82] — frozen scope explicitly leaves `autostart_*` as relabeled DW-97 stubs and current app autostart is handled by `tauri-plugin-autostart`. +- patch: Linux hotkey test was not hermetic for the X11/XWayland scenario [src-tauri/tests/platform_tests.rs:203] — ambient Wayland/X11 env could flip the result; patched. +- patch: Pure-Wayland unavailable behavior lacked an active regression test [src-tauri/tests/platform_tests.rs:210] — degradation behavior is now covered by an active Linux test. diff --git a/_bmad-output/implementation-artifacts/spec-dw-decision-dw-90.md b/_bmad-output/implementation-artifacts/spec-dw-decision-dw-90.md new file mode 100644 index 0000000..28468db --- /dev/null +++ b/_bmad-output/implementation-artifacts/spec-dw-decision-dw-90.md @@ -0,0 +1,92 @@ +--- +title: "Timeout-bound the Tauri IPC layer so a hung invoke can't wedge a singleflight key (DW-90)" +type: "bugfix" +created: "2026-06-16" +status: "done" +context: ["{project-root}/_bmad-output/project-context.md"] +baseline_commit: "37471978963b56eccb473987a93e49b610be1c5a" +--- + + + +## Intent + +**Problem:** The shared `singleflight` helper only clears an in-flight key in `started.finally(...)`. If a wrapped operation never settles — e.g. a Tauri IPC promise that hangs — the key stays in the `inFlight` map forever, so every later same-key call (`create-note`, `toggle-theme`, `toggle-layout-mode`, `trash-active-note`, `export-json`, `export-markdown`, `note-list-refresh`) coalesces onto the dead promise and that command is disabled until the app reloads. `singleflight` is deliberately timer-free (its "Never" boundary), so the bound must live elsewhere. + +**Approach:** Per the human decision (DW-90, option 1 — *Timeout at the IPC layer*), add a small `withTimeout` wrapper around the Tauri invoke calls, mirroring the CLI's 5s round-trip timeout from Story 6.7. Every IPC call made inside a singleflight-wrapped operation is raced against a timeout that rejects if the invoke never settles; the rejection flows back through the operation, so `singleflight`'s `finally` always runs and the key is released. `singleflight` itself is not touched. + +## Boundaries & Constraints + +**Always:** +- The bound lives at the IPC invoke layer (frontend), not inside `singleflight` — `singleflight` stays timer-free. +- A timed-out invoke rejects with a distinct `IpcTimeoutError` so callers' existing `try/catch` / `result.status` paths log and recover exactly as they do for any other invoke failure. +- The timer is always cleared once the invoke settles (win or lose the race) — no leaked `setTimeout`, no late unhandled rejection from the losing branch. +- Keep mirroring Story 6.7: a quick local-SQLite round-trip is bounded at 5s by default. + +**Never:** +- Do NOT add a timeout, timer, retry, or abort to `src/lib/singleflight.ts` — its "Never" boundary stands. +- Do NOT wrap the native dialog promises (`save`/`open` from `@tauri-apps/plugin-dialog`): those legitimately wait on the user and must not be killed by a 5s bound. +- Do NOT hand-edit `src/generated/bindings.ts` (tauri-specta output) and do NOT introduce raw `invoke(...)` calls — keep using the generated `commands`, wrapping the promise they return. +- Do NOT change the resolved-value contract of the `commands.*` calls on the success path. + +## I/O & Edge-Case Matrix + +| Scenario | Input / State | Expected Output / Behavior | Error Handling | +| -------- | ------------- | -------------------------- | -------------- | +| Invoke settles fast | `commands.x()` resolves before timeout | `withTimeout` resolves with the same value; timer cleared | N/A | +| Invoke rejects fast | `commands.x()` rejects before timeout | `withTimeout` rejects with that same reason; timer cleared | propagate original error | +| Invoke hangs | promise never settles, timeout elapses | `withTimeout` rejects with `IpcTimeoutError`; singleflight key released so the next call runs fresh | caller's existing catch/log path runs | +| Late settle after timeout | invoke settles *after* the timeout already won | no unhandled rejection, no double-settle, timer already cleared | swallowed (race already lost) | +| Custom bound | `withTimeout(p, { timeoutMs })` | uses the supplied bound instead of the 5s default | N/A | + + + +## Code Map + +- `src/lib/withTimeout.ts` -- NEW. The IPC timeout primitive: `withTimeout`, `IpcTimeoutError`, `IPC_TIMEOUT_MS` (5000), `EXPORT_IPC_TIMEOUT_MS` (generous bound for the long-running exports). No `singleflight` dependency. +- `src/lib/withTimeout.test.ts` -- NEW. Unit tests for the I/O matrix above (fake timers). +- `src/lib/singleflight.ts` -- UNCHANGED reference: the helper whose key gets wedged; confirms the "timer-free" boundary it must keep. +- `src/features/command-palette/actions.ts` -- wrap the IPC calls behind `create-note` / `toggle-theme` / `toggle-layout-mode`: `commands.createNote`, `commands.getConfig`, plus the shared `persistSettingsUpdate` (`commands.updateConfig`) and `applyLayoutModeToWindow` (`commands.applyLayoutMode`) helpers. +- `src/features/workspace/store.ts` -- wrap `commands.trashNote` (backs `trash-active-note`) and `commands.listNotes` in `loadFilteredNotes` (backs `note-list-refresh` and trash's follow-up reload). +- `src/features/export/exportJson.ts` -- wrap `commands.exportJson` with the export bound (dialog left unwrapped). +- `src/features/export/exportMarkdown.ts` -- wrap `commands.exportMarkdown` with the export bound (dialog/progress listener left unwrapped). + +## Tasks & Acceptance + +**Execution:** + +- [x] `src/lib/withTimeout.ts` -- create `withTimeout(operation: Promise, opts?: { timeoutMs?: number; label?: string }): Promise` that races `operation` against a `setTimeout`, rejecting with `IpcTimeoutError` on elapse and clearing the timer once `operation` settles; export `IpcTimeoutError`, `IPC_TIMEOUT_MS = 5000`, `EXPORT_IPC_TIMEOUT_MS` (generous, e.g. 60000). JSDoc on all exports. -- the IPC bound that guarantees every wrapped invoke settles. +- [x] `src/lib/withTimeout.test.ts` -- cover the I/O & Edge-Case Matrix with `vi.useFakeTimers()`: fast resolve, fast reject, hang→`IpcTimeoutError`, late settle (no unhandled rejection / no double-settle), custom `timeoutMs`. -- proves the primitive and prevents timer leaks. +- [x] `src/features/command-palette/actions.ts` -- wrap `commands.createNote`, `commands.getConfig` (both toggle flows), the inline `commands.updateConfig` awaits in `toggleTheme`/`toggleLayoutMode`, the `commands.updateConfig` await in the shared `persistSettingsUpdate`, and the `commands.applyLayoutMode` await in `applyLayoutModeToWindow` with `withTimeout(...)` (default bound). -- bounds the `create-note` / `toggle-theme` / `toggle-layout-mode` flights (and the shared settings-panel setters). +- [x] `src/features/workspace/store.ts` -- wrap `commands.trashNote` and the `commands.listNotes` await in `loadFilteredNotes` with `withTimeout(...)` (default bound). -- bounds the `trash-active-note` and `note-list-refresh` flights. +- [x] `src/features/export/exportJson.ts` -- wrap `commands.exportJson(path)` with `withTimeout(..., { timeoutMs: EXPORT_IPC_TIMEOUT_MS })`; leave the `save` dialog unwrapped. -- bounds the `export-json` flight without killing the picker. +- [x] `src/features/export/exportMarkdown.ts` -- wrap `commands.exportMarkdown(directory)` with `withTimeout(..., { timeoutMs: EXPORT_IPC_TIMEOUT_MS })`; leave the `open` dialog and progress listener unwrapped. -- bounds the `export-markdown` flight without killing the picker. + +**Acceptance Criteria:** + +- Given a `singleflight`-wrapped operation whose underlying invoke never settles, when the timeout elapses, then the wrapper rejects with `IpcTimeoutError`, the operation's existing error path runs, the `singleflight` key is released, and a subsequent same-key call invokes `fn` afresh (no permanent wedge). +- Given an invoke that resolves or rejects before the timeout, when it settles, then `withTimeout` settles with the identical value/reason and the pending timer is cleared (verified: no leaked timers, no late unhandled rejection). +- Given the native file dialogs (`save`/`open`), when an export runs, then the dialog promise is NOT timeout-bounded and the user can take arbitrarily long to choose a path/folder. +- Given `src/lib/singleflight.ts`, when this change is complete, then it contains no timer/timeout/retry/abort logic (diff shows it unchanged). + +## Verification + +**Commands:** + +- `npm run test -- src/lib/withTimeout.test.ts` -- expected: all new unit tests pass. +- `npm run test` -- expected: full Vitest suite green (existing actions/export/workspace/singleflight tests unaffected). +- `npm run build` -- expected: `tsc` typechecks clean (strict mode) and Vite build succeeds. +- `git diff --stat src/lib/singleflight.ts` -- expected: empty (singleflight untouched). + +### Review Findings + +- [x] [Review][Patch] Unbounded helper IPC could still wedge guarded create/trash flows [src/features/editor/hooks/useAutoSave.ts:46] — fixed by timeout-bounding `flushSave`'s create/update IPC and `loadNote`'s `getNote` IPC, so helper calls awaited inside `create-note` / `trash-active-note` singleflight operations now settle through `withTimeout`. +- [x] [Review][Patch] Timeout rejections bypassed existing recovery paths [src/features/workspace/store.ts:96] — fixed by catching timeout rejections in command-palette toggles, workspace trash/list loads, editor save, and note load paths so failures log and update existing failure state instead of escaping. + +#### Review Ledger (2026-06-16) + +- patch: Unbounded helper IPC could still wedge guarded create/trash flows [src/features/editor/hooks/useAutoSave.ts:46] — fixed by wrapping `commands.createNote`, `commands.updateNote`, and `commands.getNote` helper IPC with `withTimeout`. +- patch: Timeout rejections bypassed existing recovery paths [src/features/workspace/store.ts:96] — fixed by routing thrown `IpcTimeoutError` through existing log/error-state paths for toggles, trash, note-list refresh, save, and load. +- dismiss: Timed-out mutating IPC can still complete after retry [src/lib/withTimeout.ts:41] — frozen spec chose a frontend IPC timeout and explicitly documents that it cannot cancel backend commands. +- dismiss: Dialog hang path remains unresolved [src/features/export/exportJson.ts:25] — frozen spec explicitly says native `save`/`open` dialog promises must not be timeout-bounded. +- dismiss: Fixed timeout bounds may false-timeout slow valid work [src/lib/withTimeout.ts:7] — frozen spec mandates the 5s Story 6.7 mirror and a generous export bound; changing these is outside review scope. diff --git a/_bmad-output/implementation-artifacts/spec-dw-decision-dw-95.md b/_bmad-output/implementation-artifacts/spec-dw-decision-dw-95.md new file mode 100644 index 0000000..8fa3f62 --- /dev/null +++ b/_bmad-output/implementation-artifacts/spec-dw-decision-dw-95.md @@ -0,0 +1,138 @@ +--- +title: "App --socket-path CLI arg for per-run E2E IPC isolation (DW-95)" +type: "feature" +created: "2026-06-16" +status: "done" +context: [] +baseline_commit: "e03877932bcab1d48b470adfd41c8df4b7b2784e" +--- + + + +## Intent + +**Problem:** Local E2E cannot isolate its IPC socket per run. A modern WebKitWebDriver (`webkit2gtk-4.1 2.52.4`) resets the launched app's environment — stripping `NOTEY_SOCKET_PATH` and forcing `XDG_RUNTIME_DIR` back to the real session value — and `tauri-driver 2.0.6` has no env passthrough. So the test app always binds the default `$XDG_RUNTIME_DIR/notey.sock`, colliding with any real notey instance; the live-sync suite currently can only *skip* when a real instance is present rather than isolate from it. + +**Approach:** Give the desktop app a `--socket-path ` CLI argument that overrides the resolved IPC socket path, taking precedence over the `NOTEY_SOCKET_PATH` env var and the default. Route a per-run unique path through `tauri:options.args` in `e2e/run.mjs` (the tauri-driver `args` field is forwarded to the spawned binary as process args, surviving the env reset). Each E2E session then binds its own isolated endpoint regardless of env propagation, so the live-sync suite no longer needs the "real instance present → skip" guard. + +## Boundaries & Constraints + +**Always:** +- CLI-arg precedence: `--socket-path` > `NOTEY_SOCKET_PATH` env > platform default. The arg is the most explicit channel and must win. +- Parse the arg permissively from `std::env::args()` — accept both `--socket-path ` and `--socket-path=`; ignore unknown/extra args (the launcher may inject others) and never abort/exit the process on a parse miss. +- The CLI (`notey`, spawned directly by the E2E node process) keeps reading `NOTEY_SOCKET_PATH`; the app reads `--socket-path`. Both must resolve to the *same* per-run path so app and CLI rendezvous. +- Behavior must stay identical on CI (older driver where env survives) and locally — both now bind the per-run path via the arg. + +**Ask First:** +- Adding a heavyweight CLI-parsing dependency (e.g. `clap`) to the desktop crate — the single arg should be hand-parsed; do not pull in a new dep without approval. + +**Never:** +- Do not change the default/`NOTEY_SOCKET_PATH` resolution behavior for normal (no-arg) app launches. +- Do not isolate the E2E *database* — only the socket is in scope (DB sharing with a real instance is pre-existing and out of scope). +- Do not touch the IPC framing, worker, or security (`0600`) logic. + +## I/O & Edge-Case Matrix + +| Scenario | Input / State | Expected Output / Behavior | Error Handling | +| -------- | ------------- | -------------------------- | -------------- | +| Arg with space form | argv contains `--socket-path /tmp/x.sock` | `socket_path()` returns `/tmp/x.sock` | N/A | +| Arg with equals form | argv contains `--socket-path=/tmp/x.sock` | `socket_path()` returns `/tmp/x.sock` | N/A | +| Arg precedence over env | argv has `--socket-path /tmp/a.sock` AND `NOTEY_SOCKET_PATH=/tmp/b.sock` | returns `/tmp/a.sock` | N/A | +| Arg absent | argv has no `--socket-path`, env set | falls back to `NOTEY_SOCKET_PATH`, then default | N/A | +| Flag present, value missing | argv ends with `--socket-path` (no following token) | treated as absent → env/default | no panic | +| Empty value | `--socket-path=` or `--socket-path ""` | treated as absent → env/default | no panic | +| Unknown extra args | argv has other flags around `--socket-path` | extra flags ignored; arg still found | no abort | + + + +## Code Map + +- `src-tauri/src/ipc/socket_server.rs` -- `socket_path()` resolves the IPC path. Add a permissive `--socket-path` argv parser, give it top precedence, and add a unit-test module (none exists today). +- `src-tauri/src/lib.rs` -- calls `ipc::socket_server::socket_path()` at server start (line ~304). No change needed — it consumes whatever `socket_path()` returns. +- `e2e/driver.mjs` -- `createSession(application)` builds the `tauri:options` capability. Extend to forward an optional `args` array. +- `e2e/run.mjs` -- top-of-file per-run socket setup, the 5 `createSession(APP_PATH)` calls, `appSocketCandidates()`/`waitForAppSocket()` discovery, and the `realInstancePresent` skip guard in `cliLiveSyncTests()`/`main()`. + +## Tasks & Acceptance + +**Execution:** + +- [x] `src-tauri/src/ipc/socket_server.rs` -- Add a pure helper `socket_path_arg_from>(args: I) -> Option` that scans for `--socket-path ` / `--socket-path=`, returning the first non-empty value (else `None`); add `socket_path_arg()` wrapping `std::env::args()`. In `socket_path()`, check `socket_path_arg()` first, before the `NOTEY_SOCKET_PATH` env branch. Update the rustdoc on `socket_path()` to document the new precedence. +- [x] `src-tauri/src/ipc/socket_server.rs` -- Add a `#[cfg(test)] mod tests` covering every I/O & Edge-Case Matrix row for `socket_path_arg_from` (space form, equals form, missing value, empty value, unknown extra args, absent). +- [x] `e2e/driver.mjs` -- `createSession(application, args = [])`: include `args` in `tauri:options` only when non-empty. Update the JSDoc. +- [x] `e2e/run.mjs` -- Keep the per-run `NOTEY_SOCKET_PATH` assignment (for the CLI) and capture it as a constant; pass `['--socket-path', ]` to every `createSession` call (a small wrapper is fine). Simplify `appSocketCandidates()`/`waitForAppSocket()` to the now-deterministic per-run path. Remove the `realInstancePresent` detection and the live-sync skip block now that isolation is guaranteed via the arg; update the surrounding comments to reflect the arg-based isolation. + +**Acceptance Criteria:** + +- Given the app binary is launched with `--socket-path /tmp/notey-e2e.sock`, when the IPC server starts, then it binds `/tmp/notey-e2e.sock` even if `NOTEY_SOCKET_PATH` is unset/stripped and `XDG_RUNTIME_DIR` points elsewhere. +- Given the app is launched with both `--socket-path` and `NOTEY_SOCKET_PATH` set to different paths, when `socket_path()` resolves, then the `--socket-path` value wins. +- Given the app is launched with no `--socket-path`, when `socket_path()` resolves, then behavior is unchanged (env → default), so normal app launch and existing tests are unaffected. +- Given an E2E run, when each WebDriver session is created, then `tauri:options.args` carries the per-run `--socket-path`, the app and the `notey` CLI rendezvous on that path, and the live-sync suite runs (no longer skipped) even with a real notey instance on the default socket. +- Given `cargo test -p tauri-app` (or the crate's test command), when the new `socket_path_arg_from` tests run, then all matrix rows pass. + +## Design Notes + +Permissive hand-parse (no `clap` in the desktop crate) — robust to launcher-injected args and never exits the process: + +```rust +fn socket_path_arg_from>(args: I) -> Option { + let mut args = args; + while let Some(arg) = args.next() { + if let Some(v) = arg.strip_prefix("--socket-path=") { + return (!v.is_empty()).then(|| PathBuf::from(v)); + } + if arg == "--socket-path" { + return args.next().filter(|v| !v.is_empty()).map(PathBuf::from); + } + } + None +} +``` + +`socket_path()` gains one branch ahead of the env check: + +```rust +pub fn socket_path() -> PathBuf { + if let Some(custom) = socket_path_arg() { return custom; } + if let Ok(custom) = std::env::var("NOTEY_SOCKET_PATH") { return PathBuf::from(custom); } + // …existing default… +} +``` + +E2E side — both channels carry the same path; the CLI is not env-stripped (spawned directly by node), the app gets the arg: + +```js +if (!process.env.NOTEY_SOCKET_PATH) { + process.env.NOTEY_SOCKET_PATH = path.join(os.tmpdir(), `notey-e2e-${process.pid}.sock`); +} +const E2E_SOCKET_PATH = process.env.NOTEY_SOCKET_PATH; +// every session: +sessionId = await createSession(APP_PATH, ['--socket-path', E2E_SOCKET_PATH]); +``` + +## Verification + +**Commands:** + +- `cargo test -p tauri-app socket_path` -- expected: the new arg-parser unit tests pass (run from `src-tauri/`; adjust package name to the crate's actual name if different). +- `cargo build` (in `src-tauri/`) -- expected: app compiles with the new parser. +- `cargo clippy --all-targets -- -D warnings` (in `src-tauri/`) -- expected: no new warnings. +- `node --check e2e/run.mjs && node --check e2e/driver.mjs` -- expected: both parse clean. + +**Manual checks (if no CLI):** + +- Full E2E (`node e2e/run.mjs`) requires `tauri-driver` + built debug binary + xvfb; if unavailable in this environment, confirm by inspection that `tauri:options.args` carries `--socket-path` for every session and that the app's `socket_path()` returns the arg value. Note in the result if the live E2E run could not be executed here. + +### Review Findings + +- [x] [Review][Patch] Guard `--socket-path` parser against empty/malformed values while continuing to scan [src-tauri/src/ipc/socket_server.rs:116] +- [x] [Review][Patch] Normalize empty `NOTEY_SOCKET_PATH` before sharing the E2E socket path with app and CLI [e2e/run.mjs:51] +- [x] [Review][Patch] Reject a pre-existing live E2E socket before launching the test app [e2e/run.mjs:785] + +#### Review Ledger (2026-06-16) + +- patch: Guard `--socket-path` parser against empty/malformed values while continuing to scan [src-tauri/src/ipc/socket_server.rs:116] - merged blind/edge/auditor finding; malformed `--socket-path --flag` and earlier empty values must fall through instead of becoming a path or stopping the scan. +- patch: Normalize empty `NOTEY_SOCKET_PATH` before sharing the E2E socket path with app and CLI [e2e/run.mjs:51] - empty caller env split app fallback from CLI env resolution; generate a per-run path when the env var is unset or empty. +- patch: Reject a pre-existing live E2E socket before launching the test app [e2e/run.mjs:785] - prevents `waitForAppSocket()` and `notey add` from accepting an already-running listener at the chosen test path. +- dismiss: Windows custom paths are not unique by full path [src-tauri/src/ipc/socket_server.rs:201] - Windows local-socket transport already maps namespaced pipes from the final component; DW-95 uses unique per-run basenames and changing arbitrary path identity would require a coordinated CLI transport change outside this spec. + + diff --git a/_bmad-output/implementation-artifacts/spec-dw-decision-dw-97.md b/_bmad-output/implementation-artifacts/spec-dw-decision-dw-97.md new file mode 100644 index 0000000..ed4bb03 --- /dev/null +++ b/_bmad-output/implementation-artifacts/spec-dw-decision-dw-97.md @@ -0,0 +1,119 @@ +--- +title: "Route auto-start through the Platform trait (DW-97)" +type: "refactor" +created: "2026-06-17" +status: "done" +context: ["{project-root}/_bmad-output/project-context.md"] +baseline_commit: "135168ccd75f702e45cd68b0b37779d712854282" +--- + + + +## Intent + +**Problem:** The `Platform` trait declares `autostart_enable/disable/is_enabled` but every implementation is `todo!()` (DW-97), so auto-start is NOT actually routed through the trait. The real mechanism — `tauri-plugin-autostart` via `app.autolaunch()` — is reached directly from `commands/autostart.rs` and the `lib.rs` startup reconcile, because the `&self`-only trait signature cannot reach the Tauri `AppHandle` the plugin needs. The trait therefore advertises a contract it does not honor. + +**Approach:** The human chose to redesign the trait and route through it. Add `app: &tauri::AppHandle` to the three `autostart_*` trait methods, implement them on each platform by delegating to a single shared `app.autolaunch()` resolver (mirroring the existing `resolve_data_dir`/`resolve_config_dir` pattern so the plugin logic is centralized, never reimplemented per-OS), then switch `commands/autostart.rs` and the `lib.rs` reconcile block to call through `crate::platform::current()` instead of touching `autolaunch()` directly. No behavioral change to the user-facing auto-start feature (FR41–FR43 stay satisfied). + +## Boundaries & Constraints + +**Always:** +- Keep the `Platform` trait object-safe — it is returned as `Box` from `current()`. A `app: &tauri::AppHandle` parameter is object-safe; preserve that. +- Centralize the `autolaunch()` delegation in ONE place (shared `pub(crate)` helpers in `platform/mod.rs`) so all three per-OS impls are thin delegates — do NOT triplicate plugin calls. +- Preserve `set_autostart`'s existing lock discipline exactly: hold the `Mutex` across the OS change + persist, and keep the rollback-on-save-failure path. Only the calls that today hit `app.autolaunch()` change to trait calls. +- Preserve the `#[cfg(desktop)]` / `#[cfg(not(desktop))]` structure in `commands/autostart.rs` (the `not(desktop)` arms still return `Ok(false)` / persist-only) — route only the existing desktop arms through the trait. +- Keep error messages and `NoteyError` variants identical to today's wording (`Failed to enable auto-start: {e}`, `Failed to disable auto-start: {e}`, `Failed to query auto-start state: {e}`). +- The persisted `[general] auto_start` preference remains the single source of truth; OS registration is reconciled to it. Unchanged. +- Update rustdoc that currently says `autostart_*` is "deferred (DW-97)" / `todo!` across `platform/mod.rs`, `linux.rs`, `macos.rs`, `windows.rs` to describe the implemented delegation. + +**Ask First:** +- Any change to the `set_autostart`/`get_autostart` command signatures or the generated TS bindings (`src/generated/bindings.ts`) — these must NOT change; the redesign is internal to the Rust trait layer. + +**Never:** +- Do NOT hand-reimplement plist / `.desktop` / registry launch-agent logic — delegate entirely to `tauri-plugin-autostart`. +- Do NOT change the user-facing behavior, the config schema, the command names, or the IPC surface. +- Do NOT introduce a new error variant or a new dependency. +- Do NOT remove the `tauri-plugin-autostart` plugin registration in `lib.rs`. + +## I/O & Edge-Case Matrix + +| Scenario | Input / State | Expected Output / Behavior | Error Handling | +| -------- | ------------- | -------------------------- | -------------- | +| Enable via trait | `autostart_enable(&app)`, plugin succeeds | OS launch agent registered; `Ok(())` | N/A | +| Disable via trait | `autostart_disable(&app)`, plugin succeeds | OS launch agent removed; `Ok(())` | N/A | +| Query via trait | `autostart_is_enabled(&app)` | `Ok(true/false)` matching live OS registration | N/A | +| Plugin error on enable/disable | `autolaunch()` op returns `Err(e)` | propagate as `NoteyError::Config("Failed to {enable/disable} auto-start: {e}")` | mapped error | +| Plugin error on query | `is_enabled()` returns `Err(e)` | `NoteyError::Config("Failed to query auto-start state: {e}")` | mapped error | +| `set_autostart` save fails after OS change | config `save` returns `Err` | roll OS registration back to prior state via trait, then return the save error | rollback + propagate | + + + +## Code Map + +- `src-tauri/src/platform/mod.rs` -- `Platform` trait def (3 `autostart_*` signatures gain `&tauri::AppHandle`); add shared `pub(crate)` delegation helpers next to `resolve_data_dir`; update module-header rustdoc. +- `src-tauri/src/platform/linux.rs` -- replace 3 `todo!()` bodies with delegates to the shared helpers; update header. +- `src-tauri/src/platform/macos.rs` -- same. +- `src-tauri/src/platform/windows.rs` -- same. +- `src-tauri/src/commands/autostart.rs` -- `set_autostart`/`get_autostart` desktop arms call `crate::platform::current()` instead of `app.autolaunch()` directly. +- `src-tauri/src/lib.rs` -- startup reconcile block (~L228–250) calls the trait via `app.handle()` instead of `app.autolaunch()` directly. +- `src-tauri/tests/autostart_tests.rs` -- persistence-contract tests; unchanged (plugin delegation is QA-verified, not unit-testable without a Tauri runtime). Confirm still green. + +## Tasks & Acceptance + +**Execution:** + +- [x] `src-tauri/src/platform/mod.rs` -- Change the three trait methods to `fn autostart_enable(&self, app: &tauri::AppHandle) -> Result<(), NoteyError>`, `autostart_disable(&self, app: &tauri::AppHandle) -> Result<(), NoteyError>`, `autostart_is_enabled(&self, app: &tauri::AppHandle) -> Result`. Add `pub(crate)` free fns (e.g. `autostart_enable`, `autostart_disable`, `autostart_is_enabled`) that `use tauri_plugin_autostart::ManagerExt;` and call `app.autolaunch().enable()/.disable()/.is_enabled()`, mapping `Err` to `NoteyError::Config` with the exact wording above. Rewrite the module-header rustdoc so DW-97/`todo!` language is replaced by "implemented; routes through the trait." -- single delegation point + honest trait contract. +- [x] `src-tauri/src/platform/{linux,macos,windows}.rs` -- Replace each `todo!("DW-97: …")` body with a thin delegate (`super::autostart_enable(app)` etc.) and the new signature; rewrite each file-header comment to drop "deferred (DW-97)". -- per-OS impls honor the trait without duplicating plugin logic. +- [x] `src-tauri/src/commands/autostart.rs` -- In `set_autostart`, inside the existing `#[cfg(desktop)]` block, obtain `let platform = crate::platform::current();` and replace the `manager.is_enabled()` / `manager.enable()` / `manager.disable()` calls (including the rollback path) with `platform.autostart_is_enabled(&app)?` / `platform.autostart_enable(&app)` / `platform.autostart_disable(&app)`; drop the now-unused `use tauri_plugin_autostart::ManagerExt;`. In `get_autostart`, replace the `#[cfg(desktop)]` arm body with `crate::platform::current().autostart_is_enabled(&app)`. Keep all `#[cfg(not(desktop))]` arms, the lock discipline, and the error mapping unchanged. -- route commands through the trait. +- [x] `src-tauri/src/lib.rs` -- In the `#[cfg(desktop)]` auto-start reconcile block, replace `app.autolaunch()` usage with `let platform = crate::platform::current();` and `platform.autostart_is_enabled(app.handle())` / `.autostart_enable(app.handle())` / `.autostart_disable(app.handle())`; drop the local `use tauri_plugin_autostart::ManagerExt;`. Preserve the best-effort, non-fatal `eprintln!` warnings and the `desired`-vs-`active` comparison logic. -- the trait becomes the single source of truth for auto-start side effects. + +**Acceptance Criteria:** + +- Given the redesigned trait, when `cargo build` and `cargo clippy` run, then they succeed with no warnings and no remaining `todo!("DW-97…")` in the platform module. +- Given `crate::platform::current()`, when any caller needs to enable/disable/query auto-start, then it goes through `autostart_{enable,disable,is_enabled}(&app)` and NOT a direct `app.autolaunch()` call (grep for `.autolaunch()` call sites — excluding doc comments — returns nothing in `src/commands` and `src/lib.rs`; the only `.autolaunch()` calls live in `platform/mod.rs`). +- Given the `set_autostart` command, when a config save fails after the OS registration changed, then the OS registration is rolled back to its prior state through the trait before the error is returned (existing rollback contract preserved). +- Given the generated bindings, when the trait redesign is complete, then `src/generated/bindings.ts` and the `set_autostart`/`get_autostart` command signatures are byte-for-byte unchanged. +- Given `cargo test --test autostart_tests` and `cargo test --test platform_tests`, when run, then all pass. + +## Design Notes + +The shared-helper pattern already exists in `platform/mod.rs` (`resolve_data_dir`, `resolve_config_dir`, `resolve_unix_socket`). Auto-start delegation is platform-agnostic — the plugin handles plist/.desktop/registry internally — so a single shared helper per operation keeps all three OS impls one-liners and eliminates the cross-platform-divergence risk the ledger flagged: + +```rust +// platform/mod.rs +pub(crate) fn autostart_enable(app: &tauri::AppHandle) -> Result<(), NoteyError> { + use tauri_plugin_autostart::ManagerExt; + app.autolaunch() + .enable() + .map_err(|e| NoteyError::Config(format!("Failed to enable auto-start: {e}"))) +} +``` + +```rust +// platform/linux.rs (macos.rs, windows.rs identical) +fn autostart_enable(&self, app: &tauri::AppHandle) -> Result<(), NoteyError> { + super::autostart_enable(app) +} +``` + +In `lib.rs` the reconcile runs in `setup` where `app` is `&mut tauri::App`; pass `app.handle()` (an `&AppHandle`) to the trait methods. + +The autolaunch delegation cannot be unit-tested without a live Tauri runtime, so test coverage stays at the persistence contract in `autostart_tests.rs` (the established boundary — that file documents that launch-agent behavior is QA-verified). + +## Verification + +**Commands:** + +- `cd src-tauri && cargo build` -- expected: compiles clean. +- `cd src-tauri && cargo clippy --all-targets -- -D warnings` -- expected: no warnings; no `todo!` in platform module. +- `cd src-tauri && cargo test --test autostart_tests --test platform_tests` -- expected: all pass. +- `cd src-tauri && grep -rn '\.autolaunch()' src/commands src/lib.rs | grep -vE ':[0-9]+:\s*//'` -- expected: no matches (no call sites; only doc comments may mention it). +- `git diff --stat src/generated/bindings.ts` -- expected: no change. + +## Review Findings + +#### Review Ledger (2026-06-17) + +- dismiss: Unconditional autostart helper may break non-desktop builds [src-tauri/src/platform/mod.rs] — false positive: `tauri-plugin-autostart::ManagerExt` is available in the installed crate, this desktop Tauri app already registers the autostart plugin unconditionally in `lib.rs`, and the required desktop cfg command/reconcile arms still guard runtime use. +- dismiss: Public trait signature change can break undisclosed implementors/callers [src-tauri/src/platform/mod.rs] — expected spec-driven API redesign: the frozen intent explicitly requires adding `app: &tauri::AppHandle`; repository search found only the three target platform implementors and updated call sites, and clippy/tests compile cleanly. +- dismiss: Platform abstraction now depends directly on Tauri runtime state [src-tauri/src/platform/mod.rs] — intentional accepted design tradeoff: the frozen spec chose the `AppHandle` parameter specifically because `tauri-plugin-autostart` owns the launch-agent mechanism; Acceptance Auditor found no violation. diff --git a/_bmad-output/implementation-artifacts/spec-dw-hotkey-unavailable-user-notification.md b/_bmad-output/implementation-artifacts/spec-dw-hotkey-unavailable-user-notification.md new file mode 100644 index 0000000..298b871 --- /dev/null +++ b/_bmad-output/implementation-artifacts/spec-dw-hotkey-unavailable-user-notification.md @@ -0,0 +1,126 @@ +--- +title: "Hotkey-unavailable user notification (FR57 / DW-99)" +type: "feature" +created: "2026-06-17" +status: "done" +context: ["{project-root}/_bmad-output/project-context.md"] +baseline_commit: "c8fcb550dc81527ad8416a01aed037f4a11d560d" +--- + + + +## Intent + +**Problem:** When no global-shortcut backend is available on the user's compositor (pure Wayland with no XWayland, per Story 8.6 / FR57 / AC2), the app silently falls back to tray-only summoning. The only signal is an `eprintln!` in `src-tauri/src/lib.rs` (the `Err` arm of `register_hotkey`) that the user never sees, so they are left with an app that does not respond to its hotkey and no explanation. + +**Approach:** Record the hotkey availability detected at startup in Tauri-managed state, expose it through a thin read-only command, and have the frontend query it on launch and raise a toast (via the existing `src/features/toast` surface) when the hotkey backend is unavailable. The toast is persistent and click-dismissable so it survives until the user actually opens the (startup-hidden) window and acknowledges it. + +## Boundaries & Constraints + +**Always:** + +- Reuse the existing toast system (`useToastStore` / `Toaster`) — no new notification infrastructure. +- Hotkey detection stays exactly where Story 8.6 put it (the `register_hotkey` match in `lib.rs`); this work only records its outcome and surfaces it. Keep the existing `eprintln!` notice. +- All IPC via tauri-specta generated bindings (`commands.getHotkeyStatus`) — never raw `invoke`. Backend IPC struct uses `#[serde(rename_all = "camelCase")]`. +- Notification is best-effort and non-blocking: any failure querying status or showing the toast must be logged and must not affect startup or window summoning. +- The toast must remain visible long enough to be seen given the window is hidden at startup — use a persistent toast, not a short auto-dismiss. + +**Never:** + +- Do not emit the status as a `setup`-time Tauri event consumed by a frontend listener: the window is hidden and the webview listener is not yet attached when `setup` runs, so such an event is dropped (see Design Notes). Pull-on-startup is the reliable mechanism. +- Do not auto-show or focus the main window on hotkey-unavailability — surfacing the window proactively is a separate product decision, out of scope here. +- Do not change the hotkey detection logic, the registration fallback, or tray behavior. +- Do not surface the raw technical error string in the toast (log it to the console instead). + +## I/O & Edge-Case Matrix + +| Scenario | Input / State | Expected Output / Behavior | Error Handling | +| ------------------------------------------- | ----------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | --------------------------- | +| Backend available | `register_hotkey` returns `Ok` (or non-desktop build) | Managed `HotkeyStatus { available: true, reason: null }` | N/A | +| Backend unavailable | `register_hotkey` returns `Err(e)` | Managed `HotkeyStatus { available: false, reason: e.to_string() }`; existing `eprintln!` still logged | N/A | +| Frontend startup, available | `getHotkeyStatus()` → `{ available: true }` | No toast shown | N/A | +| Frontend startup, unavailable | `getHotkeyStatus()` → `{ available: false, reason }` | Persistent toast: "Global hotkey unavailable on this system — open Notey from the tray icon."; `reason` logged via `console.warn` | N/A | +| Duplicate startup invoke (React StrictMode) | `startHotkeyUnavailableNotice()` called twice | Status queried once, at most one toast | Idempotent via module guard | +| `getHotkeyStatus()` rejects | command throws | No toast; error logged | `console.error`, swallowed | +| Toast clicked | user clicks any toast card | Toast dismissed immediately | Idempotent (no-op if gone) | + + + +## Code Map + +- `src-tauri/src/models/hotkey.rs` -- NEW: `HotkeyStatus { available: bool, reason: Option }` (serde camelCase + specta `Type`) with `available()` / `unavailable(reason)` constructors. +- `src-tauri/src/models/mod.rs` -- add `pub mod hotkey;`. +- `src-tauri/src/commands/hotkey.rs` -- NEW: thin sync command `get_hotkey_status(state) -> HotkeyStatus` reading managed state; recovers a poisoned lock by cloning the inner value. +- `src-tauri/src/commands/mod.rs` -- add `pub mod hotkey;`. +- `src-tauri/src/lib.rs` -- register `commands::hotkey::get_hotkey_status` in `collect_commands!`; manage `Mutex` (default available) before the `#[cfg(desktop)]` global-shortcut block; in the `register_hotkey` match, set it to `available()` on `Ok` and `unavailable(e.to_string())` on `Err` (alongside the existing `eprintln!`). +- `src-tauri/permissions/autogenerated/get_hotkey_status.toml` -- NEW if `cargo build` does not generate it (per project-context Tauri-v2 known issue). +- `src-tauri/capabilities/default.json` -- add `"allow-get-hotkey-status"`. +- `src-tauri/tests/acl_tests.rs` -- add `"allow-get-hotkey-status"` to `EXPECTED_COMMANDS`. +- `src/generated/bindings.ts` -- regenerated by the build/`export_bindings` test (NOT hand-edited); will expose `commands.getHotkeyStatus` + `HotkeyStatus` type. +- `src/features/hotkey/unavailableNotice.ts` -- NEW: `startHotkeyUnavailableNotice()` — queries `getHotkeyStatus()`, raises the persistent toast when unavailable; module-guarded for idempotency. +- `src/features/hotkey/unavailableNotice.test.ts` -- NEW: unit tests for the matrix. +- `src/features/toast/components/Toaster.tsx` -- add click-to-dismiss on each toast card so the persistent notice can be cleared. +- `src/features/toast/components/Toaster.test.tsx` -- NEW: cover click-to-dismiss. +- `src/App.tsx` -- call `void startHotkeyUnavailableNotice()` in the startup effect (best-effort, errors logged, non-blocking). + +## Tasks & Acceptance + +**Execution:** + +- [x] `src-tauri/src/models/hotkey.rs` -- define `HotkeyStatus` (camelCase serde, specta `Type`, rustdoc) with `available()`/`unavailable(String)` constructors -- typed status carried across the IPC boundary. +- [x] `src-tauri/src/models/mod.rs` -- add `pub mod hotkey;` -- expose the new model. +- [x] `src-tauri/src/commands/hotkey.rs` -- thin sync `#[tauri::command] #[specta::specta] get_hotkey_status(State>) -> HotkeyStatus`; clone inner value, recovering a poisoned lock -- read-only IPC accessor. +- [x] `src-tauri/src/commands/mod.rs` -- add `pub mod hotkey;` -- register the command module. +- [x] `src-tauri/src/lib.rs` -- add `commands::hotkey::get_hotkey_status` to `collect_commands!`; `app.manage(Mutex::new(HotkeyStatus::available()))` before the desktop shortcut block; in the `register_hotkey` match update the managed status (`available()` on `Ok`, `unavailable(e.to_string())` on `Err`) while keeping the existing `eprintln!` -- records detection outcome for the frontend to pull. +- [x] `src-tauri/capabilities/default.json` + `src-tauri/permissions/autogenerated/get_hotkey_status.toml` -- add `"allow-get-hotkey-status"` and the perm TOML (create manually if the build skips it) -- ACL grant for the new command. +- [x] `src-tauri/tests/acl_tests.rs` -- add `"allow-get-hotkey-status"` to `EXPECTED_COMMANDS` -- keep the ACL coverage test green. +- [x] `src/features/hotkey/unavailableNotice.ts` -- `startHotkeyUnavailableNotice()`: query `commands.getHotkeyStatus()`; if `!available`, `useToastStore.getState().addToast(message, 0)` (persistent) and `console.warn` the reason; idempotent via module guard; swallow+log errors -- frontend surface wiring. +- [x] `src/features/toast/components/Toaster.tsx` -- add `onClick={() => dismissToast(toast.id)}` (cursor pointer, `title="Dismiss"`) to each toast card -- lets the user clear the persistent notice. +- [x] `src/App.tsx` -- invoke `void startHotkeyUnavailableNotice()` in the startup effect, non-blocking -- triggers the pull on launch. +- [x] `src/features/hotkey/unavailableNotice.test.ts` + `src/features/toast/components/Toaster.test.tsx` -- unit-test the I/O & Edge-Case Matrix (unavailable→persistent toast + warn, available→none, idempotency, command rejection, click-dismiss) -- and a Rust `#[cfg(test)]` in `models/hotkey.rs` asserting camelCase serialization (`available`, `reason`). + +### Review Findings + +- [x] [Review][Patch] `Ok` arm should record `HotkeyStatus::available()` [src-tauri/src/lib.rs:300] -- fixed in review: the successful backend-probe arm now explicitly writes `HotkeyStatus::available()` to managed state, matching the frozen Code Map requirement instead of relying only on the default. +- [x] [Review][Patch] Toast click-dismiss control needs keyboard accessibility [src/features/toast/components/Toaster.tsx:37] -- fixed in review: toast cards are now semantic buttons with an accessible dismiss label, preserving click dismissal while allowing keyboard and assistive-technology dismissal. + +#### Review Ledger (2026-06-17) + +- patch: `Ok` arm should record `HotkeyStatus::available()` [src-tauri/src/lib.rs:300] -- fixed; Acceptance Auditor correctly found the frozen spec required an explicit available write in the `Ok` arm. +- patch: Toast click-dismiss control needs keyboard accessibility [src/features/toast/components/Toaster.tsx:37] -- fixed; Edge Case Hunter correctly found the persistent dismiss affordance was mouse-only. +- dismiss: Non-desktop builds default to hotkey available [src-tauri/src/lib.rs:257] -- specified behavior; the frozen I/O matrix says non-desktop builds produce `available: true`. +- dismiss: Registration failure after backend probe should mark status unavailable [src-tauri/src/lib.rs:305] -- out of scope; this status tracks backend availability per FR57, while shortcut conflicts remain existing logged/rebind behavior. +- dismiss: One-shot guard suppresses retry after `getHotkeyStatus()` rejection [src/features/hotkey/unavailableNotice.ts:33] -- specified behavior; the matrix requires rejection to log, swallow, and show no toast. +- dismiss: All toasts are now click-dismissable [src/features/toast/components/Toaster.tsx:40] -- specified behavior; the Code Map calls for click-to-dismiss on each toast card. +- dismiss: Missing visible close-button text [src/features/toast/components/Toaster.tsx:41] -- no product requirement for a separate close button; fixed accessibility through semantic button labeling. +- dismiss: Tray guidance may be wrong if tray is unavailable [src/features/hotkey/unavailableNotice.ts:10] -- out of scope; the approved message explicitly directs users to the tray icon. +- dismiss: Technical reason is only logged, not displayed [src/features/hotkey/unavailableNotice.ts:38] -- specified behavior; frozen constraints forbid surfacing the raw technical error in the toast. +- dismiss: Generated `getHotkeyStatus` binding is not wrapped with `typedError` [src/generated/bindings.ts:114] -- expected codegen for a command returning plain `HotkeyStatus` rather than `Result`. +- dismiss: `HotkeyStatus` derives `Deserialize` unnecessarily [src-tauri/src/models/hotkey.rs:18] -- harmless consistency with other IPC models, not a behavioral risk. +- dismiss: Click-dismiss test relies on event bubbling [src/features/toast/components/Toaster.test.tsx:24] -- superseded by added semantic-button coverage. + +**Acceptance Criteria:** + +- Given a session where `register_hotkey` returns `Err`, when the app starts and the frontend queries `getHotkeyStatus`, then a persistent toast tells the user the hotkey is unavailable and to use the tray, and the technical reason is logged to the console. +- Given a session where the hotkey registers successfully, when the app starts, then no hotkey toast is shown. +- Given the startup effect runs twice (React StrictMode), when `startHotkeyUnavailableNotice` is invoked again, then at most one toast is shown. +- Given the persistent toast is visible, when the user clicks it, then it is dismissed. +- Given `getHotkeyStatus` is unavailable or rejects, when the notice runs, then startup and window summoning are unaffected and the error is logged. + +## Design Notes + +**Why pull, not a `setup`-time event.** The intent (DW-99) suggested emitting a typed Tauri event from the `Err` arm and adding a frontend listener. That is unreliable here: the `main` window is configured `visible: false` (`tauri.conf.json`), the webview loads asynchronously, and the `register_hotkey` match runs early in the synchronous `setup` hook — well before the React `useEffect` listener attaches. Tauri does not buffer events for not-yet-registered listeners, so the event would be dropped. Recording the outcome in managed state and letting the frontend pull it on startup is race-free and matches the codebase's existing startup-state pattern (e.g. `get_onboarding_state`). This is a deliberate deviation from the suggested mechanism, logged as a PREFERENCE. + +**Persistent toast.** Because the window is hidden at startup, a normal 3s auto-dismiss toast would expire before the user ever opens the window. The notice is added persistently (`addToast(msg, 0)` — non-positive duration skips the auto-dismiss timer, per the existing store contract) and click-to-dismiss is added to the `Toaster` so the user can clear it after reading. The export-progress toast already relies on the persistent path, so this reuses an established store capability. + +**Managing the status.** `app.manage(Mutex::new(HotkeyStatus::available()))` is done unconditionally so the command always has state (including non-desktop builds where the `#[cfg(desktop)]` shortcut block is compiled out). The desktop block updates the managed value through the lock, mirroring the existing `Mutex` pattern. + +## Verification + +**Commands:** + +- `cd src-tauri && cargo test` -- expected: all pass, including `acl_tests` (new `allow-get-hotkey-status`) and the `HotkeyStatus` serde test. +- `cd src-tauri && cargo test export_bindings` -- expected: regenerates `src/generated/bindings.ts` with `commands.getHotkeyStatus` and the `HotkeyStatus` type. +- `cd src-tauri && cargo clippy --all-targets -- -D warnings` -- expected: clean. +- `npm run test` -- expected: new `unavailableNotice` and `Toaster` tests pass; existing toast/store tests unaffected. +- `npx tsc --noEmit && npx eslint src/features/hotkey src/features/toast src/App.tsx` -- expected: no type or lint errors. diff --git a/_bmad-output/implementation-artifacts/spec-dw-release-pipeline-multi-target.md b/_bmad-output/implementation-artifacts/spec-dw-release-pipeline-multi-target.md new file mode 100644 index 0000000..050f06a --- /dev/null +++ b/_bmad-output/implementation-artifacts/spec-dw-release-pipeline-multi-target.md @@ -0,0 +1,176 @@ +--- +title: "Release pipeline producing artifacts for all five targets (DW-98)" +type: "chore" +created: "2026-06-17" +status: "done" +baseline_commit: "46ea161dbcb1c7ff3227f266af09d09157b0da7f" +context: ["{project-root}/_bmad-output/project-context.md"] +--- + + + +## Intent + +**Problem:** AC4 of story 8.6 requires distributable build artifacts for five +targets — Windows x64, macOS x64, macOS ARM64, Linux x64, Linux ARM64 — but the +repo has no release workflow. `ci.yml` only runs tests plus a Linux debug build, +so tagging a release produces nothing. + +**Approach:** Add a net-new `.github/workflows/release.yml` that fires on a +release tag push and uses `tauri-apps/tauri-action` with a five-entry runner +matrix to build and upload bundles for all five targets to a GitHub Release. + +## Boundaries & Constraints + +**Always:** Match this repo's existing CI conventions (npm + `npm ci`, Node 22, +the pinned `nightly-2026-04-03` toolchain, the same Linux apt dependency set as +`ci.yml`). Use the Tauri-recommended macOS split (one matrix entry per arch via +`--target`) and native `ubuntu-22.04-arm` runner for Linux ARM64. Pin +third-party actions to the same major versions already used in `ci.yml`. +Release must be created as a **draft** (artifacts are unsigned per project +context — a human publishes after review). + +**Ask First:** Switching Linux ARM64 from a native ARM runner to +cross-compilation/emulation. Adding code-signing or notarization secrets. +Changing the tag trigger pattern. + +**Never:** Modify `ci.yml` or any existing workflow. Touch application code, +`tauri.conf.json`, `package.json`, or Rust sources. Add network/telemetry to the +app. Introduce auto-update infrastructure. Rename the product (`productName` is +out of scope for this deliverable). + +## I/O & Edge-Case Matrix + +| Scenario | Input / State | Expected Output / Behavior | Error Handling | +| -------- | ------------- | -------------------------- | -------------- | +| Tag push | `git push` of a tag matching `v*` | Workflow triggers; five matrix jobs run; bundles uploaded to a draft GitHub Release for that tag | `fail-fast: false` so one target's failure does not cancel the others | +| Manual run | `workflow_dispatch` from the Actions UI | Same five-job matrix executes | N/A | +| Non-tag push | push to a branch | Workflow does NOT trigger | N/A | + + + +## Code Map + +- `.github/workflows/release.yml` -- NEW. The entire deliverable. +- `.github/workflows/ci.yml` -- REFERENCE ONLY. Source of repo conventions + (toolchain pin, apt deps, Node version, action major versions). Do not edit. +- `src-tauri/tauri.conf.json` -- REFERENCE ONLY. `bundle.active: true`, + `bundle.targets: "all"` — confirms tauri-action will produce platform bundles. +- `rust-toolchain.toml` -- REFERENCE ONLY. Pins `nightly-2026-04-03` (required by + specta); the workflow must install this exact toolchain, not `stable`. + +## Tasks & Acceptance + +**Execution:** + +- [x] `.github/workflows/release.yml` -- Create the release workflow: + - Trigger: `on: push: tags: ['v*']` plus `workflow_dispatch`. + - `permissions: contents: write` (needed to create the Release). + - Matrix (`fail-fast: false`) of five entries: + - `macos-latest` + `args: --target aarch64-apple-darwin` (macOS ARM64) + - `macos-15-intel` + `args: --target x86_64-apple-darwin` (macOS x64) + - `ubuntu-22.04` + `args: ''` (Linux x64) + - `ubuntu-22.04-arm` + `args: ''` (Linux ARM64) + - `windows-latest` + `args: ''` (Windows x64) + - Steps: `actions/checkout@v6`; install Linux apt deps (same list as `ci.yml`: + `libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf libxdo-dev`) + on both ubuntu runners; `actions/setup-node@v6` (Node 22, `cache: npm`); + `dtolnay/rust-toolchain@master` with `toolchain: nightly-2026-04-03` and macOS + `targets: aarch64-apple-darwin,x86_64-apple-darwin`; `swatinem/rust-cache@v2` + scoped to `./src-tauri -> target`; `npm ci`; then `tauri-apps/tauri-action@v0` + with `GITHUB_TOKEN`, tag push/manual-dispatch-safe `tagName`, + matching `releaseName`, `releaseDraft: true`, `prerelease: false`, + `args: ${{ matrix.args }}`. + +**Acceptance Criteria:** + +- Given a tag matching `v*` is pushed, when the workflow runs, then exactly five + matrix jobs execute covering Windows x64, macOS x64, macOS ARM64, Linux x64, + and Linux ARM64. +- Given the macOS jobs, when they build, then each targets a single architecture + via its `--target` arg and the toolchain has both apple-darwin targets added. +- Given any single target's build fails, when the matrix runs, then the remaining + targets still build (`fail-fast: false`). +- Given the workflow file, when linted/parsed as YAML and GitHub Actions syntax, + then it is valid with no syntax or schema errors. + +### Review Findings + +- [x] [Review][Patch] macOS x64 job used ARM64 `macos-latest` runner + [.github/workflows/release.yml:25] +- [x] [Review][Patch] manual dispatch could create branch-named releases + [.github/workflows/release.yml:10] +- [x] [Review][Patch] deferred-work resolution overstated `actionlint` + validation and named the stale macOS matrix + [_bmad-output/implementation-artifacts/deferred-work.md:777] + +#### Review Ledger (2026-06-17) + +- patch: macOS x64 job used ARM64 `macos-latest` runner + [.github/workflows/release.yml:25] — changed the x64 matrix row to + `macos-15-intel` and broadened macOS Rust target installation to all + `macos-*` matrix labels. +- patch: manual dispatch could create branch-named releases + [.github/workflows/release.yml:10] — added a required `releaseTag` input, + checks out that tag on manual runs, validates the `v*` pattern, and uses that + tag for the release name/tag. +- patch: deferred-work resolution overstated `actionlint` validation and named + the stale macOS matrix [_bmad-output/implementation-artifacts/deferred-work.md:777] + — updated the closeout text to match the corrected matrix and actual + verification result. +- dismiss: Linux ARM64 depends on a runner label that may not exist + [.github/workflows/release.yml:29] — current GitHub-hosted runner docs list + `ubuntu-22.04-arm`, and the current Tauri pipeline guide uses it for Linux + ARM64. +- dismiss: release action runs concurrently against the same release + [.github/workflows/release.yml:69] — the current Tauri pipeline guide uses + the same matrix pattern with `tauri-apps/tauri-action` creating/updating one + draft release across matrix jobs. +- dismiss: prerelease-looking tags are always marked stable + [.github/workflows/release.yml:78] — the approved execution checklist + explicitly requires `prerelease: false`, and releases remain draft for human + review before publication. + +## Design Notes + +Tag-push releases use the pushed tag itself, and manual dispatch uses the +required `releaseTag` input for checkout plus release naming. This attaches the +Release to an explicit version tag rather than the docs' branch-push + +`__VERSION__` pattern, because the intent specifies a release-tag workflow. + +Toolchain deviates from the Tauri docs (which use `@stable`): this repo is pinned +to `nightly-2026-04-03` in `rust-toolchain.toml` (specta RC requirement), so the +release build must install that exact nightly or it will not compile. + +Linux ARM64 uses the GitHub-hosted native `ubuntu-22.04-arm` runner (the current +Tauri-recommended approach, free on public repos) — far simpler and more reliable +than cross-compilation or QEMU emulation. + +Manual dispatch requires an explicit existing `releaseTag` input and checks out +that tag before building, so a run from `main` or a feature branch cannot create +a branch-named draft release. + +## Spec Change Log + +- 2026-06-17 review: amended the non-frozen matrix checklist from + `macos-latest` to `macos-15-intel` for the macOS x64 job. Current GitHub + runner docs map `macos-latest` to ARM64, so retaining `macos-latest` for the + x64 row risked producing only ARM-hosted macOS artifacts while claiming Intel + coverage. + +## Verification + +This workflow only runs on a real release tag push and cannot be exercised by the +local cargo/vitest gate. Verification is config-correctness review. + +**Commands:** + +- `python3 -c "import yaml,sys; yaml.safe_load(open('.github/workflows/release.yml'))"` -- expected: exits 0 (valid YAML). +- `actionlint .github/workflows/release.yml` -- expected: no errors (if `actionlint` is available; skip if not installed). + +**Manual checks:** + +- Confirm five matrix entries map 1:1 to the five required targets. +- Confirm action versions match `ci.yml` majors (`checkout@v6`, `setup-node@v6`, + `dtolnay/rust-toolchain@master`) and `tauri-action@v0`. +- Confirm `releaseDraft: true` and `permissions: contents: write` are present. diff --git a/_bmad-output/implementation-artifacts/sprint-status.yaml b/_bmad-output/implementation-artifacts/sprint-status.yaml index c3d6237..86ec795 100644 --- a/_bmad-output/implementation-artifacts/sprint-status.yaml +++ b/_bmad-output/implementation-artifacts/sprint-status.yaml @@ -40,7 +40,7 @@ # - Dev moves story to 'review', then runs code-review (fresh context, different LLM recommended) generated: 2026-04-03 -last_updated: 2026-06-16 # epic-6-retro item-1 (E2E) note corrected + local live-sync E2E fixed (DW-95; 16/16 local); item 5 (DW-85) → done; items 1+2 previously → done +last_updated: 2026-06-17 # story 8-6 → done # Note: epic-2-retrospective rewritten fresh on 2026-04-04 project: notey project_key: NOKEY @@ -132,13 +132,13 @@ development_status: epic-7-retrospective: optional # Epic 8: Onboarding & Platform Integration - epic-8: backlog - 8-1-first-run-detection-onboarding-overlay: backlog - 8-2-macos-accessibility-permission-guidance: backlog - 8-3-hotkey-customization-during-onboarding: backlog - 8-4-auto-start-on-login: backlog - 8-5-per-user-data-isolation: backlog - 8-6-cross-platform-verification-wayland-fallback: backlog + epic-8: in-progress + 8-1-first-run-detection-onboarding-overlay: done + 8-2-macos-accessibility-permission-guidance: done + 8-3-hotkey-customization-during-onboarding: done + 8-4-auto-start-on-login: done + 8-5-per-user-data-isolation: done + 8-6-cross-platform-verification-wayland-fallback: done epic-8-retrospective: optional # ═══════════════════════════════════════════════ diff --git a/docs/architecture.md b/docs/architecture.md new file mode 100644 index 0000000..b095c83 --- /dev/null +++ b/docs/architecture.md @@ -0,0 +1,77 @@ +# Architecture + +A high-level overview of how Notey is built. For exhaustive design records see the +planning artifacts under `_bmad-output/planning-artifacts/` (PRD, architecture +decision document, and epic breakdown). + +## Stack + +| Layer | Technology | +| --- | --- | +| Shell | [Tauri 2](https://tauri.app) (Wry webview) | +| Front end | React 19 + TypeScript, Vite, Tailwind CSS, Zustand | +| Editor | CodeMirror 6 | +| Back end | Rust | +| Storage | SQLite (via rusqlite) with FTS5 full-text search | +| IPC types | [tauri-specta](https://github.com/oscartbeaumont/tauri-specta) (generated TS bindings) | + +## Shape + +``` +┌────────────────────────────────────────────┐ +│ Tauri window (Wry webview) │ +│ ┌────────────────────────────────────────┐ │ +│ │ React front end (src/) │ │ +│ │ feature modules: editor, tabs, search, │ │ +│ │ note-list, command-palette, settings, │ │ +│ │ trash, workspace, onboarding, theme … │ │ +│ └───────────────┬────────────────────────┘ │ +│ │ type-safe IPC (specta) │ +│ ┌───────────────▼────────────────────────┐ │ +│ │ Rust back end (src-tauri/) │ │ +│ │ commands → services → db (SQLite/FTS5) │ │ +│ │ platform abstraction (mac/linux/win) │ │ +│ │ local socket server ◄── notey CLI │ │ +│ └────────────────────────────────────────┘ │ +└────────────────────────────────────────────┘ +``` + +## Front end (`src/`) + +Organized by **feature** rather than by file type — each feature owns its Zustand +store, components, and API calls. Shared UI primitives live in `components/ui/`. +The Rust↔TS contract is generated into `src/generated/bindings.ts`, so command and +event signatures are type-checked end to end. + +## Back end (`src-tauri/`) + +A layered design: + +- **`commands/`** — thin `#[tauri::command]` handlers exposed to the front end. +- **`services/`** — business logic (notes, workspaces, search, config, export, + onboarding, window layout). +- **`db/`** — SQLite schema, migrations, and the FTS5 search index. +- **`platform/`** — a trait-based abstraction isolating macOS/Linux/Windows + specifics (data/config/socket paths, hotkey backend, accessibility). +- **`ipc/`** — a local socket server and protocol that lets the `notey` CLI drive + the running app and emit live-sync events. + +## Data & search + +Notes live in a local SQLite database with WAL mode. Full-text search uses SQLite's +**FTS5** extension with BM25 ranking and an external-content table kept in sync via +triggers. Everything is local — there is no network server and no telemetry. + +## IPC and the CLI + +Beyond the webview↔Rust bridge, the back end runs a small **local socket server**. +The standalone `notey` CLI connects to it to add, list, and search notes; new notes +broadcast an event the desktop app listens for, so the UI updates live. See the +[CLI guide](cli.md). + +## Platform integration + +Notey registers a global capture hotkey, a system tray, and (optionally) auto-start +on login. The global shortcut backend is abstracted per platform; on pure Wayland +without XWayland the OS hotkey may be unavailable, in which case the window stays +reachable from the tray (a native Wayland portal is on the [roadmap](../ROADMAP.md)). diff --git a/docs/cli.md b/docs/cli.md new file mode 100644 index 0000000..3dee8d3 --- /dev/null +++ b/docs/cli.md @@ -0,0 +1,70 @@ +# Command-line interface + +Notey ships a companion `notey` command-line tool that talks to the **running** +desktop app over a local IPC socket. Notes you add from the terminal appear in the +app immediately (live sync). + +> The CLI is under active development; the command surface below reflects the +> current implementation. + +## How it works + +The desktop app exposes a per-user local socket (a Unix domain socket, or a named +pipe on Windows). The `notey` CLI connects to it, sends a request, and prints the +response. Because both talk to the same database through the app, the CLI and the +desktop UI always agree — and the app's note list refreshes the moment the CLI adds +a note. + +The desktop app must be **running** for the CLI to work. If it isn't, the CLI exits +with a non-zero status indicating the app is not running. + +## Commands + +### `notey add` + +Create a note. + +```sh +notey add "Pick up milk" # quick note +notey add "## TODO\n- ship docs" --format markdown +echo "piped content" | notey add --stdin # read the body from stdin +``` + +- `--stdin` — read the note content from standard input instead of an argument. +- `--format ` — note format (defaults to `markdown`). + +### `notey list` + +List notes, most recently updated first. + +```sh +notey list +notey list --workspace my-project # filter to a workspace +``` + +### `notey search` + +Full-text search across your notes. + +```sh +notey search "release checklist" +notey search "fts5" --workspace notey +``` + +## Exit codes + +| Code | Meaning | +| --- | --- | +| `0` | Success | +| `1` | The app returned an error | +| `2` | The app is not running, or the request timed out | + +## Building the CLI + +The CLI is a standalone crate: + +```sh +cd notey-cli +cargo build # debug binary at notey-cli/target/debug/notey +cargo build --release # optimized binary +``` diff --git a/docs/configuration.md b/docs/configuration.md new file mode 100644 index 0000000..55573a2 --- /dev/null +++ b/docs/configuration.md @@ -0,0 +1,58 @@ +# Configuration + +Notey stores its settings as TOML in a per-user config file. Most options are +editable from **Settings** (`Ctrl+,`); advanced users can edit the file directly. + +## Where the config lives + +| Platform | Path | +| --- | --- | +| Linux | `$XDG_CONFIG_HOME/notey/config.toml` (usually `~/.config/notey/config.toml`) | +| macOS | `~/Library/Application Support/notey/config.toml` | +| Windows | `%APPDATA%\notey\config.toml` | + +Your notes database is stored separately in the platform **data** directory +(e.g. `~/.local/share/notey/notey.db` on Linux). + +## Options + +The file is divided into sections. All keys have sensible defaults, so a missing +key or section falls back to the shipped value. + +```toml +[general] +theme = "system" # "system" | "dark" | "light" (default: system) +layoutMode = "floating" # "floating" | "halfScreen" | "fullScreen" (default: floating) +autoStart = false # launch Notey on login (default: false) + +[editor] +fontSize = 14 # editor font size in px (default: 14) +fontFamily = "mono" # "mono" | "sans" (default: mono) + +[hotkey] +globalShortcut = "Ctrl+Shift+N" # global capture hotkey (macOS default: Cmd+Shift+N) + +[shortcuts] +commandPalette = "Ctrl+P" +search = "Ctrl+F" +newNote = "Ctrl+N" +toggleNoteList = "Ctrl+B" +toggleTheme = "Ctrl+Shift+T" +closeTab = "Ctrl+W" + +[trash] +retentionDays = 30 # days a trashed note is kept before auto-purge (default: 30) +``` + +### Notes on values + +- **theme** — `system` follows your OS appearance until you pick `dark` or `light`; + an explicit choice persists across restarts. +- **globalShortcut** / **[shortcuts]** — canonical form is + `[Ctrl|Cmd]+[Shift]+[Alt]+KEY` where `KEY` is a letter or number. The in-app + shortcuts treat `Ctrl` and `Cmd` interchangeably and display `⌘` on macOS. +- **retentionDays** — trashed notes older than this are purged automatically on + startup. + +Settings changed in the UI are written back to this file. If you edit the file by +hand, restart Notey to be sure changes are picked up cleanly. diff --git a/docs/images/command-palette-dark.png b/docs/images/command-palette-dark.png new file mode 100644 index 0000000..c891c3a Binary files /dev/null and b/docs/images/command-palette-dark.png differ diff --git a/docs/images/command-palette.png b/docs/images/command-palette.png new file mode 100644 index 0000000..9b2e26a Binary files /dev/null and b/docs/images/command-palette.png differ diff --git a/docs/images/editor-dark.png b/docs/images/editor-dark.png new file mode 100644 index 0000000..364f87d Binary files /dev/null and b/docs/images/editor-dark.png differ diff --git a/docs/images/editor-light.png b/docs/images/editor-light.png new file mode 100644 index 0000000..4550ee0 Binary files /dev/null and b/docs/images/editor-light.png differ diff --git a/docs/images/note-list.png b/docs/images/note-list.png new file mode 100644 index 0000000..f76ebb7 Binary files /dev/null and b/docs/images/note-list.png differ diff --git a/docs/images/onboarding.png b/docs/images/onboarding.png new file mode 100644 index 0000000..41d73de Binary files /dev/null and b/docs/images/onboarding.png differ diff --git a/docs/images/search.png b/docs/images/search.png new file mode 100644 index 0000000..2357a32 Binary files /dev/null and b/docs/images/search.png differ diff --git a/docs/images/settings-general.png b/docs/images/settings-general.png new file mode 100644 index 0000000..de1911e Binary files /dev/null and b/docs/images/settings-general.png differ diff --git a/docs/images/trash.png b/docs/images/trash.png new file mode 100644 index 0000000..6ed6650 Binary files /dev/null and b/docs/images/trash.png differ diff --git a/docs/images/workspace-selector.png b/docs/images/workspace-selector.png new file mode 100644 index 0000000..3fe4462 Binary files /dev/null and b/docs/images/workspace-selector.png differ diff --git a/docs/installation.md b/docs/installation.md new file mode 100644 index 0000000..76ec1d2 --- /dev/null +++ b/docs/installation.md @@ -0,0 +1,73 @@ +# Installation + +Notey runs natively on macOS, Linux, and Windows. + +## Download a release + +The easiest way to install Notey is to grab a prebuilt bundle from the +[Releases page](https://github.com/pbean/notey/releases). Release builds are +produced for: + +- **macOS** — Apple Silicon (arm64) and Intel (x64) +- **Linux** — x64 and arm64 +- **Windows** — x64 + +Download the artifact for your platform and install it the usual way for your OS +(open the `.dmg` on macOS, the `.AppImage`/`.deb` on Linux, or the installer on +Windows). + +> Release artifacts are currently unsigned. Your OS may warn you on first launch; +> allow the app to run via your platform's standard "open anyway" flow. + +## First launch + +Notey starts **hidden** in the system tray — there is no window on screen at +first. To open it: + +- Press the global capture hotkey: **`Ctrl+Shift+N`** (**`Cmd+Shift+N`** on macOS), or +- Click the Notey tray icon and choose **Open Notey**. + +On first run you'll see a short onboarding overlay showing the capture hotkey, +which you can customize. On macOS you may be prompted to grant Accessibility +permission so the global hotkey can work. + +See the [user guide](user-guide.md) to learn your way around. + +## Auto-start on login + +To have Notey launch automatically when you log in, open **Settings** +(`Ctrl+,`) and enable **Start on login**. + +## Build from source + +You'll need: + +- **Node.js** 20+ and **npm** +- **Rust** via [rustup](https://rustup.rs) (the pinned toolchain in + `rust-toolchain.toml` is selected automatically) +- The [Tauri system dependencies](https://tauri.app/start/prerequisites/) for your OS + +On Debian/Ubuntu Linux: + +```sh +sudo apt-get install -y \ + libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf libxdo-dev +``` + +Then: + +```sh +git clone https://github.com/pbean/notey.git +cd notey +npm install + +# Run in development (hot-reload): +npm run tauri dev + +# Or produce an optimized build for your platform: +npx tauri build +``` + +The bundled installers/binaries are written under `src-tauri/target/release/bundle/`. + +For the full contributor setup, see [CONTRIBUTING.md](../CONTRIBUTING.md). diff --git a/docs/keyboard-shortcuts.md b/docs/keyboard-shortcuts.md new file mode 100644 index 0000000..bb974ad --- /dev/null +++ b/docs/keyboard-shortcuts.md @@ -0,0 +1,44 @@ +# Keyboard shortcuts + +Notey is keyboard-first. On macOS, use **`Cmd`** wherever **`Ctrl`** is shown. + +## Global (works system-wide) + +| Action | Shortcut | Notes | +| --- | --- | --- | +| Summon / dismiss Notey | `Ctrl+Shift+N` | The global capture hotkey. Customizable in onboarding and Settings. Availability depends on the OS compositor. | + +## Configurable in-app shortcuts + +These act when Notey is focused and can be rebound in **Settings → Shortcuts** +(`Ctrl+,`). Defaults: + +| Action | Default | +| --- | --- | +| Command palette | `Ctrl+P` | +| Search notes | `Ctrl+F` | +| New note | `Ctrl+N` | +| Toggle note list | `Ctrl+B` | +| Toggle theme | `Ctrl+Shift+T` | +| Close tab | `Ctrl+W` | + +Rebindings must use `Ctrl`/`Cmd` with an optional `Shift`/`Alt` and a letter or +number; conflicting bindings are detected and rejected. + +## Reserved shortcuts (not rebindable) + +| Action | Shortcut | +| --- | --- | +| Open settings | `Ctrl+,` | +| Next tab | `Ctrl+Tab` | +| Previous tab | `Ctrl+Shift+Tab` | +| Jump to tab 1–9 | `Ctrl+1` … `Ctrl+9` | +| Close overlay / hide window | `Esc` | + +## In overlays and lists + +| Action | Key | +| --- | --- | +| Move selection | `↑` / `↓` | +| Open / confirm selection | `Enter` | +| Close overlay | `Esc` | diff --git a/docs/user-guide.md b/docs/user-guide.md new file mode 100644 index 0000000..8f73f04 --- /dev/null +++ b/docs/user-guide.md @@ -0,0 +1,110 @@ +# User guide + +This guide walks through Notey's features. For the complete shortcut list see +[Keyboard shortcuts](keyboard-shortcuts.md); for settings see +[Configuration](configuration.md). + +## First run + +On first launch Notey reveals itself and shows an onboarding overlay with the +capture hotkey. You can customize the hotkey there, then dismiss the overlay by +pressing `Esc` or the hotkey itself. On macOS, grant Accessibility permission when +prompted so the global hotkey works. + +![Onboarding overlay](images/onboarding.png) + +## Summoning and dismissing + +Notey lives in the system tray and stays out of your way until you need it. + +- **Summon:** press the global hotkey (`Ctrl+Shift+N`, or `Cmd+Shift+N` on macOS), + or click the tray icon → **Open Notey**. +- **Dismiss:** press `Esc`, or press the hotkey again. The window hides — it never + quits — so your work is right where you left it next time. +- **Quit:** use the tray menu → **Quit**. + +## Capturing notes + +Type into the editor and Notey saves automatically — there is no save button. The +status bar shows the save state (saving / **Saved** / failed) on the right. + +![Editor](images/editor-light.png) + +- **New note:** `Ctrl+N`. +- **Format:** toggle between **Markdown** and **Plain text** from the status bar or + the command palette. The choice is remembered per note. + +## Tabs + +Keep several notes open at once. The tab bar runs along the top. + +- **Next / previous tab:** `Ctrl+Tab` / `Ctrl+Shift+Tab`. +- **Jump to tab 1–9:** `Ctrl+1` … `Ctrl+9`. +- **Close tab:** `Ctrl+W`. + +Tabs, cursor position, and scroll are restored when you reopen Notey. + +## The command palette + +Press `Ctrl+P` to open the command palette — a fuzzy-searchable menu of every +action: new note, search, trash, export, settings, theme, layout, and more. + +![Command palette](images/command-palette.png) + +## Workspaces + +Notes are grouped into **workspaces**, typically tied to a project directory. The +workspace selector lives in the status bar (bottom-left). + +![Workspace selector](images/workspace-selector.png) + +- Switch the active workspace from the selector or the **Switch Workspace** command. +- Choose **All Workspaces** to see notes from every workspace at once. + +## Search + +Press `Ctrl+F` to open full-text search. Results rank by relevance (FTS5/BM25) and +show match snippets. Scope the search to the current workspace or all workspaces. + +![Search](images/search.png) + +## The note list + +Press `Ctrl+B` to slide out the note list for the current workspace. Navigate with +the arrow keys and press `Enter` to open a note. + +![Note list](images/note-list.png) + +## Trash & restore + +Deleting a note moves it to the trash (it isn't gone). Open **View Trash** from the +command palette to restore notes or delete them permanently. + +![Trash](images/trash.png) + +Trashed notes are automatically purged after the retention window (default 30 days +— see [Configuration](configuration.md)). + +## Export + +From the command palette: + +- **Export to Markdown** — writes one `.md` file per note into a folder you choose. +- **Export to JSON** — writes all your notes to a single JSON document. + +## Personalization + +Open **Settings** with `Ctrl+,`. + +![Settings](images/settings-general.png) + +- **Theme:** System / Dark / Light. Toggle quickly with `Ctrl+Shift+T`. +- **Layout:** Floating (the always-on-top capture window), Half-screen, or + Full-screen. +- **Font:** size and family (monospace or sans-serif). +- **Shortcuts:** rebind in-app shortcuts; conflicts are detected and rejected. +- **Start on login:** launch Notey automatically when you log in. + +Notey looks right in the dark, too: + +![Dark theme](images/editor-dark.png) diff --git a/e2e/driver.mjs b/e2e/driver.mjs index dfd4f87..fb2a67a 100644 --- a/e2e/driver.mjs +++ b/e2e/driver.mjs @@ -20,12 +20,25 @@ async function request(method, path, body) { return json.value; } -export async function createSession(application) { +/** + * Create a WebDriver session that launches the Tauri app. + * + * @param {string} application - Absolute path to the app binary. + * @param {string[]} [args] - Command-line arguments forwarded to the launched + * binary via `tauri:options.args` (tauri-driver passes them through as process + * args). Used to route a per-run `--socket-path`, which survives a modern + * WebKitWebDriver resetting the app's environment. Omitted from the capability + * when empty. + * @returns {Promise} The created session id. + */ +export async function createSession(application, args = []) { + const tauriOptions = { application }; + if (args.length > 0) tauriOptions.args = args; const value = await request('POST', '/session', { capabilities: { alwaysMatch: { browserName: 'wry', - 'tauri:options': { application }, + 'tauri:options': tauriOptions, }, }, }); @@ -166,6 +179,15 @@ export async function executeAsyncScript(sessionId, script, args = []) { return request('POST', `/session/${sessionId}/execute/async`, { script, args }); } +/** + * Capture the current viewport as a PNG via the W3C `Take Screenshot` command. + * Returns a base64-encoded PNG string (the W3C-specified encoding); callers + * decode with `Buffer.from(value, 'base64')` before writing to disk. + */ +export async function takeScreenshot(sessionId) { + return request('GET', `/session/${sessionId}/screenshot`); +} + export function pause(ms) { return new Promise((resolve) => setTimeout(resolve, ms)); } diff --git a/e2e/run.mjs b/e2e/run.mjs index 3126d35..f05df84 100644 --- a/e2e/run.mjs +++ b/e2e/run.mjs @@ -35,11 +35,23 @@ process.env.LIBGL_ALWAYS_SOFTWARE ??= '1'; // Pin a unique per-run IPC socket so the CLI live-sync suite rendezvous's the // test app and the `notey` CLI on their own endpoint — never colliding with a // real notey instance the developer may have running on the default -// `$XDG_RUNTIME_DIR/notey.sock`. Set before the driver spawns so it inherits -// down node → tauri-driver → app (same chain as the WEBKIT vars above), and the -// CLI (spawned from this process) reads the same value. `??=` lets a caller -// override it. -process.env.NOTEY_SOCKET_PATH ??= path.join(os.tmpdir(), `notey-e2e-${process.pid}.sock`); +// `$XDG_RUNTIME_DIR/notey.sock`. A non-empty caller-provided NOTEY_SOCKET_PATH +// can still override it. +// +// The same path is carried over two independent channels because a modern +// WebKitWebDriver (webkit2gtk ≥2.52) resets the launched app's environment — +// stripping NOTEY_SOCKET_PATH — and tauri-driver has no env passthrough: +// - The APP receives it as a `--socket-path` CLI arg via `tauri:options.args` +// (see `createSession`), which survives the env reset and binds the app to +// this exact endpoint regardless of env propagation. +// - The CLI (spawned directly by this process, so its env is intact) reads +// NOTEY_SOCKET_PATH. +// Both resolve to the same path, so every run is fully isolated — even with a +// real notey instance listening on the default socket. +if (!process.env.NOTEY_SOCKET_PATH) { + process.env.NOTEY_SOCKET_PATH = path.join(os.tmpdir(), `notey-e2e-${process.pid}.sock`); +} +const E2E_SOCKET_PATH = process.env.NOTEY_SOCKET_PATH; import { createSession, @@ -61,7 +73,7 @@ import { } from './driver.mjs'; const __dirname = path.dirname(fileURLToPath(import.meta.url)); -const APP_PATH = path.resolve(__dirname, '..', 'src-tauri', 'target', 'debug', 'tauri-app'); +const APP_PATH = path.resolve(__dirname, '..', 'src-tauri', 'target', 'debug', 'notey'); const ESCAPE = '\uE00C'; const ENTER = '\uE007'; const CONTROL = '\uE009'; @@ -70,9 +82,15 @@ let tauriDriver; let sessionId; let passed = 0; let failed = 0; -// Set once, before any test app launches: whether a real notey instance already -// owns the default IPC socket (see the live-sync suite's guard for why it matters). -let realInstancePresent = false; + +/** + * Launch a fresh WebDriver session for the test app, routing the per-run IPC + * socket through `--socket-path` so the app binds the isolated endpoint even + * when the WebKitWebDriver build resets its environment. + */ +function launchSession() { + return createSession(APP_PATH, ['--socket-path', E2E_SOCKET_PATH]); +} async function test(name, fn) { try { @@ -354,22 +372,6 @@ async function waitForMarkerInNoteList(marker, timeoutMs = 5000) { throw new Error(`Note list never showed CLI-added marker "${marker}" within ${timeoutMs}ms`); } -/** - * Paths the app's IPC server may have bound, in priority order. The app resolves - * its socket as NOTEY_SOCKET_PATH → `$XDG_RUNTIME_DIR/notey.sock` → temp fallback - * (mirrors `socket_server::socket_path`). We export a unique per-run - * NOTEY_SOCKET_PATH, but a modern WebKitWebDriver (webkit2gtk ≥2.52) resets the - * launched app's environment — stripping NOTEY_SOCKET_PATH and forcing - * XDG_RUNTIME_DIR back to the real session value — and tauri-driver has no env - * passthrough, so the harness cannot steer the app's path: it must discover it. - * On CI's older driver the env survives, so the first candidate wins and behavior - * is unchanged. - */ -function appSocketCandidates() { - const xdg = process.env.XDG_RUNTIME_DIR; - return [process.env.NOTEY_SOCKET_PATH, xdg ? path.join(xdg, 'notey.sock') : null].filter(Boolean); -} - /** * Whether a Unix socket path is *accepting connections* (a live server), as * opposed to a leftover stale socket file. A probe connect that immediately @@ -393,19 +395,19 @@ function isSocketLive(p, timeoutMs = 500) { } /** - * Poll until one of the app's candidate IPC sockets is *live*, and return that - * path. The app's IPC server binds during Tauri's setup hook, which can lag a - * freshly-created WebDriver session on a cold runner — without this gate the first - * `notey add` races the bind and fails exit-2 ("not running"). Liveness (not mere - * file existence) is checked so a leftover stale socket never wins over the path - * the app actually bound. Returns null after the deadline, leaving the CLI's own - * connect timeout to report a genuine absence. + * Poll until the app's per-run IPC socket (`E2E_SOCKET_PATH`, routed via + * `--socket-path`) is *live*, then return it. The app's IPC server binds during + * Tauri's setup hook, which can lag a freshly-created WebDriver session on a cold + * runner — without this gate the first `notey add` races the bind and fails + * exit-2 ("not running"). Liveness (not mere file existence) is checked so a + * leftover stale socket file never counts as ready. Returns null after the + * deadline, leaving the CLI's own connect timeout to report a genuine absence. */ async function waitForAppSocket(timeoutMs = 5000) { const deadline = Date.now() + timeoutMs; while (Date.now() < deadline) { - for (const c of appSocketCandidates()) { - if (fs.existsSync(c) && (await isSocketLive(c))) return c; + if (fs.existsSync(E2E_SOCKET_PATH) && (await isSocketLive(E2E_SOCKET_PATH))) { + return E2E_SOCKET_PATH; } await pause(150); } @@ -632,20 +634,9 @@ async function purgeCliNote(marker) { async function cliLiveSyncTests() { console.log('\nP1-E2E-003: CLI Live Sync'); - // A modern WebKitWebDriver resets the test app's env, forcing it onto the - // default `$XDG_RUNTIME_DIR/notey.sock` — the same endpoint a real desktop notey - // uses. If a real instance was already listening there before we launched, the - // CLI would talk to IT (polluting the real DB) instead of the test app. Skip - // rather than hijack; CI never trips this (no real instance, env survives). - if (realInstancePresent) { - console.log( - ' ⚠ skipped: a running notey instance owns the default IPC socket. ' + - 'Close it to run the live-sync suite locally — this WebKitWebDriver build ' + - 'resets the app env, preventing per-run socket isolation.', - ); - return; - } - + // The app binds the per-run socket via its `--socket-path` arg (see + // `launchSession`), so this suite is fully isolated from any real notey + // instance on the default `$XDG_RUNTIME_DIR/notey.sock` — no skip guard needed. // Unique per run so the marker note is identifiable in a non-isolated dev DB. const marker = `E2E-CLISYNC-${Date.now()}`; let addSucceeded = false; @@ -672,12 +663,12 @@ async function cliLiveSyncTests() { }); await test('notey add (CLI, separate process) exits 0', async () => { - // Discover where the app actually bound (its env may not survive the - // WebDriver launch) and point the CLI at that exact socket. The CLI reads - // NOTEY_SOCKET_PATH at spawn, so updating it here steers `runCli` below. + // Gate on the app's IPC server actually being live before the CLI connects + // (the bind lags session creation on a cold runner). The app and CLI share + // E2E_SOCKET_PATH — the app via `--socket-path`, the CLI via the inherited + // NOTEY_SOCKET_PATH env — so no path reassignment is needed. const appSocket = await waitForAppSocket(); - assert(appSocket, `app IPC socket never came up; tried: ${appSocketCandidates().join(', ')}`); - process.env.NOTEY_SOCKET_PATH = appSocket; + assert(appSocket, `app IPC socket never came up at ${E2E_SOCKET_PATH}`); const res = await runCli(['add', marker]); assert(res.code === 0, `CLI exited ${res.code}; stderr: "${res.stderr.trim()}"`); addSucceeded = true; @@ -791,19 +782,18 @@ async function exportTests() { // --- Main --- async function main() { - // Detect a real notey instance on the default socket BEFORE launching the test - // app (which, under a modern WebKitWebDriver, binds that same default path). Once - // the test app is up we can't tell its socket apart from a pre-existing one. - const xdg = process.env.XDG_RUNTIME_DIR; - const defaultSock = xdg ? path.join(xdg, 'notey.sock') : null; - realInstancePresent = !!(defaultSock && fs.existsSync(defaultSock) && (await isSocketLive(defaultSock))); + if (fs.existsSync(E2E_SOCKET_PATH) && (await isSocketLive(E2E_SOCKET_PATH))) { + throw new Error( + `E2E IPC socket path is already live before launching the test app: ${E2E_SOCKET_PATH}`, + ); + } console.log('Starting tauri-driver...'); await startDriver(); try { console.log('Creating session...'); - sessionId = await createSession(APP_PATH); + sessionId = await launchSession(); console.log(`Session: ${sessionId}`); // Give the app time to fully initialize @@ -815,7 +805,7 @@ async function main() { await deleteSession(sessionId); await pause(2000); - sessionId = await createSession(APP_PATH); + sessionId = await launchSession(); await pause(3000); await windowManagementTests(); @@ -824,7 +814,7 @@ async function main() { await deleteSession(sessionId); await pause(2000); - sessionId = await createSession(APP_PATH); + sessionId = await launchSession(); await pause(3000); await trashLifecycleTests(); @@ -833,7 +823,7 @@ async function main() { await deleteSession(sessionId); await pause(2000); - sessionId = await createSession(APP_PATH); + sessionId = await launchSession(); await pause(3000); await cliLiveSyncTests(); @@ -842,7 +832,7 @@ async function main() { await deleteSession(sessionId); await pause(2000); - sessionId = await createSession(APP_PATH); + sessionId = await launchSession(); await pause(3000); await exportTests(); diff --git a/e2e/screenshots.mjs b/e2e/screenshots.mjs new file mode 100644 index 0000000..31501c4 --- /dev/null +++ b/e2e/screenshots.mjs @@ -0,0 +1,432 @@ +#!/usr/bin/env node +/** + * Documentation screenshot capture for Notey, via tauri-driver. + * + * Drives the real debug binary through the same tauri-driver + WebKitWebDriver + * stack as `e2e/run.mjs`, seeds deterministic sample data over the real IPC + * bridge, opens each view/overlay, and writes a PNG per view to `docs/images/`. + * + * Usage: node e2e/screenshots.mjs (or `npm run screenshots`) + * + * Prerequisites (identical to the E2E suite): + * - tauri-driver installed (cargo install --locked tauri-driver) + * - WebKitWebDriver available (webkit2gtk-driver package) + * - Debug binary built (npx tauri build --debug --no-bundle) → target/debug/notey + * - A display: a real X server (DISPLAY set) renders real pixels; under a + * headless box wrap with `xvfb-run -a node e2e/screenshots.mjs`. + * + * The capture window launches hidden (`visible:false`); this script shows it + * before each shot so the OS compositor renders real content. It writes to the + * app's own data dir (identifier com.pinkyd.notey) — running it adds the sample + * notes to your local Notey database. + */ + +import { spawn, spawnSync } from 'child_process'; +import path from 'path'; +import os from 'os'; +import fs from 'fs'; +import { fileURLToPath } from 'url'; + +// Force WebKitGTK software rendering before anything spawns the driver — same +// rationale as e2e/run.mjs: the accelerated-compositing + DMABUF paths crash the +// web process under a GPU-less framebuffer and wedge every WebDriver command. +process.env.WEBKIT_DISABLE_COMPOSITING_MODE ??= '1'; +process.env.WEBKIT_DISABLE_DMABUF_RENDERER ??= '1'; +process.env.LIBGL_ALWAYS_SOFTWARE ??= '1'; + +// Isolate the IPC socket so a real Notey instance on the default socket is never +// disturbed (mirrors run.mjs; carried to the app via --socket-path). +if (!process.env.NOTEY_SOCKET_PATH) { + process.env.NOTEY_SOCKET_PATH = path.join(os.tmpdir(), `notey-shots-${process.pid}.sock`); +} +const SOCKET_PATH = process.env.NOTEY_SOCKET_PATH; + +import { + createSession, + deleteSession, + executeScript, + executeAsyncScript, + findElement, + elementId, + sendKeysToElement, + sendSpecialKey, + sendChord, + takeScreenshot, + pause, +} from './driver.mjs'; + +const __dirname = path.dirname(fileURLToPath(import.meta.url)); +const APP_PATH = path.resolve(__dirname, '..', 'src-tauri', 'target', 'debug', 'notey'); +const OUT_DIR = path.resolve(__dirname, '..', 'docs', 'images'); +const ESCAPE = ''; +const ENTER = ''; +const CONTROL = ''; + +let tauriDriver; +let sessionId; +let captured = 0; +let failed = 0; + +// --- Driver lifecycle (mirrors e2e/run.mjs) --- + +/** + * Best-effort reap of leftover driver processes. tauri-driver spawns a + * WebKitWebDriver child that does NOT exit when tauri-driver is killed, so a + * prior crashed/SIGKILLed run can orphan one holding port 4445 — which makes the + * next run's driver fail to bind and every command return "fetch failed". Clear + * them before starting so the script is self-healing across runs. + */ +function reapOrphanDrivers() { + for (const name of ['tauri-driver', 'WebKitWebDriver']) { + spawnSync('pkill', ['-9', '-f', name], { stdio: 'ignore' }); + } +} + +async function startDriver() { + reapOrphanDrivers(); + await pause(500); + tauriDriver = spawn('tauri-driver', [], { stdio: ['ignore', 'ignore', 'pipe'] }); + let stderr = ''; + let spawnError = null; + tauriDriver.stderr.on('data', (c) => { stderr += c; }); + tauriDriver.on('error', (e) => { spawnError = e; }); + for (let i = 0; i < 60; i++) { + if (spawnError) break; + try { + await fetch('http://127.0.0.1:4444/status'); + return; + } catch { + await pause(500); + } + } + if (stderr) console.error('tauri-driver stderr:\n' + stderr); + throw spawnError || new Error('tauri-driver did not start within 30 seconds'); +} + +function stopDriver() { + if (tauriDriver) { + tauriDriver.kill('SIGKILL'); + tauriDriver = null; + } + // SIGKILL orphans the WebKitWebDriver child — reap it so the next run starts clean. + reapOrphanDrivers(); +} + +function launchSession() { + return createSession(APP_PATH, ['--socket-path', SOCKET_PATH]); +} + +// --- Helpers --- + +async function waitForCss(selector, timeoutMs = 8000) { + const deadline = Date.now() + timeoutMs; + let lastErr; + while (Date.now() < deadline) { + try { + return elementId(await findElement(sessionId, 'css selector', selector)); + } catch (e) { + lastErr = e; + await pause(150); + } + } + throw lastErr || new Error(`Timed out waiting for ${selector}`); +} + +async function clickCss(selector, timeoutMs = 8000) { + await waitForCss(selector, timeoutMs); + await executeScript(sessionId, 'document.querySelector(arguments[0]).click();', [selector]); +} + +/** Invoke a real Tauri command from the page; resolve `{ ok, value | err }`. */ +async function invokeCommand(cmd, args) { + return executeAsyncScript( + sessionId, + `var done = arguments[arguments.length - 1]; + window.__TAURI_INTERNALS__.invoke(arguments[0], arguments[1]) + .then(function (v) { done({ ok: true, value: v }); }) + .catch(function (e) { done({ ok: false, err: String((e && e.message) || e) }); });`, + [cmd, args], + ); +} + +/** Open the command palette and run the command labelled `label`. */ +async function runPaletteCommand(label) { + await sendChord(sessionId, CONTROL, 'p'); + const input = await waitForCss('[data-testid="command-input"]'); + await pause(120); + await sendKeysToElement(sessionId, input, label); + await pause(350); + await sendSpecialKey(sessionId, ENTER); + await pause(400); +} + +/** + * Show + focus the (hidden-on-launch) capture window so the compositor renders + * real pixels for the screenshot. Best-effort across the Tauri v2 internal + * window-command shapes; failures are non-fatal (a mapped X server still + * composites the webview surface for WebKitWebDriver). + */ +async function showWindow() { + for (const args of [{}, { label: 'main' }]) { + const r = await invokeCommand('plugin:window|show', args).catch(() => null); + if (r?.ok) break; + } + await invokeCommand('plugin:window|set_focus', {}).catch(() => null); + await pause(300); +} + +/** Capture the viewport to docs/images/.png. */ +async function capture(name) { + try { + await showWindow(); + const b64 = await takeScreenshot(sessionId); + const buf = Buffer.from(b64, 'base64'); + if (buf.length < 1000) throw new Error(`screenshot suspiciously small (${buf.length} bytes)`); + fs.writeFileSync(path.join(OUT_DIR, `${name}.png`), buf); + captured++; + console.log(` ✓ ${name}.png (${(buf.length / 1024).toFixed(0)} KB)`); + } catch (e) { + failed++; + console.log(` ✗ ${name}.png — ${e.message}`); + } +} + +/** Launch a fresh session, resetting onboarding so the first-run reveal maps the window. */ +async function newSession() { + forceFirstRunReveal(); + sessionId = await launchSession(); + await pause(3500); // app init + first-run reveal +} + +/** Tear down the current session and let the app/socket settle before the next. */ +async function endSession() { + if (sessionId) await deleteSession(sessionId).catch(() => {}); + sessionId = null; + await pause(1500); +} + +/** Dismiss the first-run onboarding overlay if present. */ +async function dismissOnboarding() { + try { + await waitForCss('[data-testid="onboarding-overlay"]', 5000); + await sendSpecialKey(sessionId, ESCAPE); + await pause(700); + } catch { + /* not shown — nothing to dismiss */ + } +} + +/** + * Run `fn` inside a fresh session, always tearing it down afterwards. Used for + * side-effecting steps (seeding) that don't capture. + */ +async function withSession(label, fn) { + try { + await newSession(); + await fn(); + } catch (e) { + console.log(` ! ${label}: ${e.message}`); + } finally { + await endSession(); + } +} + +/** + * Capture one view in its own fresh session. A new WebKitWebDriver web process + * per shot avoids the cumulative instability that crashes a long single session + * (the same reason e2e/run.mjs relaunches between suites). `navigate` opens the + * target view; `theme` is applied (and persisted) before navigating. + */ +async function shot(name, { theme, navigate } = {}) { + try { + await newSession(); + await dismissOnboarding(); + if (theme) { + await setTheme(theme); + await pause(400); + } + if (navigate) await navigate(); + await capture(name); + } catch (e) { + failed++; + console.log(` ✗ ${name}.png — ${e.message}`); + } finally { + await endSession(); + } +} + +/** Set the theme via the real config command and let the webview re-apply it. */ +async function setTheme(theme) { + await invokeCommand('update_config', { partial: { general: { theme } } }).catch(() => null); + await pause(500); +} + +/** + * Resolve the platform config dir the app will use (mirrors src-tauri's + * `resolve_config_dir("notey")` via the `dirs` crate) and remove + * `onboarding.toml`. This forces the app's first-run reveal, which *maps* the + * capture window — a never-mapped window makes WebKitWebDriver's screenshot + * command crash the session. Non-destructive: the notes database lives in the + * separate data dir and is untouched; onboarding state regenerates on dismiss. + */ +function forceFirstRunReveal() { + let base; + if (process.platform === 'darwin') { + base = path.join(os.homedir(), 'Library', 'Application Support'); + } else if (process.platform === 'win32') { + base = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'); + } else { + base = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'); + } + const onboarding = path.join(base, 'notey', 'onboarding.toml'); + try { + fs.rmSync(onboarding, { force: true }); + console.log(`Reset onboarding state (${onboarding}) to force first-run reveal.`); + } catch (e) { + console.log(`Could not reset onboarding state: ${e.message}`); + } +} + +// --- Sample data --- + +async function seed() { + // Two workspaces rooted at real, existing directories (create_workspace + // canonicalizes the path). The repo dir and the home dir always exist. + const repoRoot = path.resolve(__dirname, '..'); + await invokeCommand('create_workspace', { name: 'Notey', path: repoRoot }).catch(() => null); + await invokeCommand('create_workspace', { name: 'Personal', path: os.homedir() }).catch(() => null); + + const notes = [ + `# Release checklist\n\n- [x] Tag v0.1.0\n- [ ] Draft GitHub release notes\n- [ ] Capture fresh screenshots\n- [ ] Announce on the changelog`, + `# Meeting notes — sync\n\nDecisions:\n- Ship the workspace selector in the status bar\n- Keep the capture window at 720×480\n\nFollow-ups:\n- Wire FTS5 snippets into search results`, + `# Ideas\n\nA quick-capture note tool that disappears when you Esc. Global hotkey summons it, tabs hold what you're juggling, and full-text search finds it later.`, + `# Shell snippets\n\n\`\`\`sh\nrg --files | fzf\ngit log --oneline --graph\n\`\`\``, + `Plain scratch buffer — todo: reply to the docs thread.`, + ]; + for (const content of notes) { + const created = await invokeCommand('create_note', { format: 'markdown', workspaceId: null }); + if (created?.ok && created.value?.id != null) { + await invokeCommand('update_note', { + id: created.value.id, + title: null, + content, + format: null, + }); + } + } + await pause(400); +} + +// --- Capture sequence --- + +// Navigation closures used by the per-view sessions. + +async function typeSampleNote() { + await sendChord(sessionId, CONTROL, 'n'); + await pause(400); + const content = await waitForCss('.cm-content'); + await sendKeysToElement( + sessionId, + content, + '# Standup\n\n- Shipped the trash lifecycle\n- Reviewing the CLI live-sync seam\n- Next: docs + screenshots', + ); + await pause(900); // auto-save debounce + round-trip +} + +async function openPalette() { + await sendChord(sessionId, CONTROL, 'p'); + await waitForCss('[data-testid="command-palette"]'); + await pause(300); +} + +async function openSearch() { + await runPaletteCommand('Search Notes'); + const search = await waitForCss('[data-testid="search-input"]'); + await sendKeysToElement(sessionId, search, 'release'); + await pause(500); +} + +async function openNoteList() { + await sendChord(sessionId, CONTROL, 'b'); + await waitForCss('[data-testid="note-list-panel"]'); + await pause(300); +} + +async function openSettings() { + await runPaletteCommand('Open Settings'); + await waitForCss('[data-testid="settings-overlay"]'); + await pause(300); +} + +async function openWorkspaceMenu() { + await executeScript(sessionId, 'document.querySelector(arguments[0]).focus();', [ + '[data-testid="workspace-name"]', + ]); + await sendSpecialKey(sessionId, ENTER); + await pause(400); +} + +async function openTrash() { + // Create a throwaway note, move it to trash, then view the panel. + await sendChord(sessionId, CONTROL, 'n'); + await pause(300); + const tmp = await waitForCss('.cm-content'); + await sendKeysToElement(sessionId, tmp, 'Draft to discard'); + await pause(800); + await runPaletteCommand('Move to Trash'); + await pause(400); + await runPaletteCommand('View Trash'); + await waitForCss('[data-testid="trash-panel"]'); + await pause(300); +} + +async function main() { + fs.mkdirSync(OUT_DIR, { recursive: true }); + + console.log('Starting tauri-driver...'); + await startDriver(); + + try { + // First-run onboarding overlay — captured in its own session before dismissal. + console.log('\nOnboarding (first run):'); + await withSession('onboarding', async () => { + await waitForCss('[data-testid="onboarding-overlay"]', 6000); + await capture('onboarding'); + }); + + // Seed sample notes + workspaces once; they persist in the notes DB and are + // reused by every subsequent view session. + console.log('\nSeeding sample data...'); + await withSession('seed', async () => { + await dismissOnboarding(); + await seed(); + }); + + console.log('\nLight theme:'); + await shot('editor-light', { theme: 'light', navigate: typeSampleNote }); + await shot('command-palette', { theme: 'light', navigate: openPalette }); + await shot('search', { theme: 'light', navigate: openSearch }); + await shot('note-list', { theme: 'light', navigate: openNoteList }); + await shot('settings-general', { theme: 'light', navigate: openSettings }); + await shot('workspace-selector', { theme: 'light', navigate: openWorkspaceMenu }); + await shot('trash', { theme: 'light', navigate: openTrash }); + + console.log('\nDark theme:'); + await shot('editor-dark', { theme: 'dark', navigate: typeSampleNote }); + await shot('command-palette-dark', { theme: 'dark', navigate: openPalette }); + } catch (e) { + console.error('Fatal error:', e.message); + failed++; + } finally { + if (sessionId) await deleteSession(sessionId).catch(() => {}); + stopDriver(); + } + + console.log( + `\nCaptured ${captured} screenshot(s) into ${path.relative(process.cwd(), OUT_DIR)}/` + + (failed ? `, ${failed} failed` : ''), + ); + process.exit(failed > 0 ? 1 : 0); +} + +main(); diff --git a/package.json b/package.json index 0473e67..b827a25 100644 --- a/package.json +++ b/package.json @@ -1,7 +1,14 @@ { - "name": "tauri-app", + "name": "notey", "private": true, "version": "0.1.0", + "description": "Notey — a fast, keyboard-driven, workspace-aware note-capture desktop app.", + "author": "Paul Bean ", + "license": "MIT", + "repository": { + "type": "git", + "url": "git+https://github.com/pbean/notey.git" + }, "type": "module", "scripts": { "dev": "vite", @@ -9,7 +16,8 @@ "preview": "vite preview", "tauri": "tauri", "test": "vitest run", - "test:e2e": "node e2e/run.mjs" + "test:e2e": "node e2e/run.mjs", + "screenshots": "node e2e/screenshots.mjs" }, "dependencies": { "@base-ui/react": "^1.3.0", diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock index 5dc78c2..03cebc2 100644 --- a/src-tauri/Cargo.lock +++ b/src-tauri/Cargo.lock @@ -213,6 +213,17 @@ version = "1.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0" +[[package]] +name = "auto-launch" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1f012b8cc0c850f34117ec8252a44418f2e34a2cf501de89e29b241ae5f79471" +dependencies = [ + "dirs 4.0.0", + "thiserror 1.0.69", + "winreg 0.10.1", +] + [[package]] name = "autocfg" version = "1.5.0" @@ -737,6 +748,15 @@ dependencies = [ "crypto-common", ] +[[package]] +name = "dirs" +version = "4.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca3aa72a6f96ea37bbc5aa912f6788242832f75369bdfdadcb0e38423f100059" +dependencies = [ + "dirs-sys 0.3.7", +] + [[package]] name = "dirs" version = "5.0.1" @@ -755,6 +775,17 @@ dependencies = [ "dirs-sys 0.5.0", ] +[[package]] +name = "dirs-sys" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b1d1d91c932ef41c0f2663aa8b0ca0342d444d842c06914aa0a7e352d0bada6" +dependencies = [ + "libc", + "redox_users 0.4.6", + "winapi", +] + [[package]] name = "dirs-sys" version = "0.4.1" @@ -908,7 +939,7 @@ dependencies = [ "rustc_version", "toml 0.9.12+spec-1.1.0", "vswhom", - "winreg", + "winreg 0.55.0", ] [[package]] @@ -2300,6 +2331,34 @@ version = "0.1.14" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "72ef4a56884ca558e5ddb05a1d1e7e1bfd9a68d9ed024c21704cc98872dae1bb" +[[package]] +name = "notey" +version = "0.1.0" +dependencies = [ + "chrono", + "dirs 5.0.1", + "dunce", + "interprocess", + "libc", + "rusqlite", + "rusqlite_migration", + "serde", + "serde_json", + "specta", + "specta-typescript", + "tauri", + "tauri-build", + "tauri-plugin-autostart", + "tauri-plugin-dialog", + "tauri-plugin-global-shortcut", + "tauri-plugin-opener", + "tauri-specta", + "tempfile", + "thiserror 1.0.69", + "toml 0.8.2", + "windows", +] + [[package]] name = "num-conv" version = "0.2.1" @@ -3999,33 +4058,6 @@ dependencies = [ "windows", ] -[[package]] -name = "tauri-app" -version = "0.1.0" -dependencies = [ - "chrono", - "dirs 5.0.1", - "dunce", - "interprocess", - "libc", - "rusqlite", - "rusqlite_migration", - "serde", - "serde_json", - "specta", - "specta-typescript", - "tauri", - "tauri-build", - "tauri-plugin-dialog", - "tauri-plugin-global-shortcut", - "tauri-plugin-opener", - "tauri-specta", - "tempfile", - "thiserror 1.0.69", - "toml 0.8.2", - "windows", -] - [[package]] name = "tauri-build" version = "2.6.2" @@ -4105,6 +4137,20 @@ dependencies = [ "walkdir", ] +[[package]] +name = "tauri-plugin-autostart" +version = "2.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "459383cebc193cdd03d1ba4acc40f2c408a7abce419d64bdcd2d745bc2886f70" +dependencies = [ + "auto-launch", + "serde", + "serde_json", + "tauri", + "tauri-plugin", + "thiserror 2.0.18", +] + [[package]] name = "tauri-plugin-dialog" version = "2.7.1" @@ -5133,7 +5179,7 @@ version = "0.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" dependencies = [ - "windows-sys 0.48.0", + "windows-sys 0.61.2", ] [[package]] @@ -5629,6 +5675,15 @@ dependencies = [ "memchr", ] +[[package]] +name = "winreg" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "80d0f4e272c85def139476380b12f9ac60926689dd2e01d4923222f40580869d" +dependencies = [ + "winapi", +] + [[package]] name = "winreg" version = "0.55.0" diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml index 496192c..92f8ae0 100644 --- a/src-tauri/Cargo.toml +++ b/src-tauri/Cargo.toml @@ -1,8 +1,10 @@ [package] -name = "tauri-app" +name = "notey" version = "0.1.0" -description = "A Tauri App" -authors = ["you"] +description = "Notey — a fast, keyboard-driven, workspace-aware note-capture desktop app." +authors = ["Paul Bean "] +license = "MIT" +repository = "https://github.com/pbean/notey" edition = "2021" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html @@ -11,7 +13,7 @@ edition = "2021" # The `_lib` suffix may seem redundant but it is necessary # to make the lib name unique and wouldn't conflict with the bin name. # This seems to be only an issue on Windows, see https://github.com/rust-lang/cargo/issues/8519 -name = "tauri_app_lib" +name = "notey_lib" crate-type = ["staticlib", "cdylib", "rlib"] [features] @@ -29,6 +31,7 @@ tauri = { version = "2", default-features = false, features = ["wry", "compressi tauri-plugin-opener = "2" tauri-plugin-global-shortcut = "2" tauri-plugin-dialog = "2" +tauri-plugin-autostart = "2" serde = { version = "1", features = ["derive"] } serde_json = "1" rusqlite = { version = "0.34", features = ["bundled", "modern_sqlite"] } diff --git a/src-tauri/capabilities/default.json b/src-tauri/capabilities/default.json index 8f1ca32..16c61eb 100644 --- a/src-tauri/capabilities/default.json +++ b/src-tauri/capabilities/default.json @@ -5,12 +5,19 @@ "windows": ["main"], "permissions": [ "core:default", + "core:window:allow-show", + "core:window:allow-set-focus", "opener:default", "dialog:allow-open", "dialog:allow-save", "global-shortcut:allow-register", "global-shortcut:allow-unregister", "global-shortcut:allow-is-registered", + "autostart:allow-enable", + "autostart:allow-disable", + "autostart:allow-is-enabled", + "allow-set-autostart", + "allow-get-autostart", "allow-create-note", "allow-get-note", "allow-update-note", @@ -21,6 +28,11 @@ "allow-list-notes", "allow-get-config", "allow-update-config", + "allow-get-onboarding-state", + "allow-complete-onboarding", + "allow-increment-onboarding-session", + "allow-check-accessibility-permission", + "allow-open-accessibility-settings", "allow-dismiss-window", "allow-apply-layout-mode", "allow-create-workspace", @@ -33,6 +45,7 @@ "allow-rebuild-fts-index", "allow-search-notes", "allow-export-markdown", - "allow-export-json" + "allow-export-json", + "allow-get-hotkey-status" ] } diff --git a/src-tauri/permissions/autogenerated/check_accessibility_permission.toml b/src-tauri/permissions/autogenerated/check_accessibility_permission.toml new file mode 100644 index 0000000..4eff8d6 --- /dev/null +++ b/src-tauri/permissions/autogenerated/check_accessibility_permission.toml @@ -0,0 +1,11 @@ +# Automatically generated - DO NOT EDIT! + +[[permission]] +identifier = "allow-check-accessibility-permission" +description = "Enables the check_accessibility_permission command without any pre-configured scope." +commands.allow = ["check_accessibility_permission"] + +[[permission]] +identifier = "deny-check-accessibility-permission" +description = "Denies the check_accessibility_permission command without any pre-configured scope." +commands.deny = ["check_accessibility_permission"] diff --git a/src-tauri/permissions/autogenerated/complete_onboarding.toml b/src-tauri/permissions/autogenerated/complete_onboarding.toml new file mode 100644 index 0000000..47e92b1 --- /dev/null +++ b/src-tauri/permissions/autogenerated/complete_onboarding.toml @@ -0,0 +1,11 @@ +# Automatically generated - DO NOT EDIT! + +[[permission]] +identifier = "allow-complete-onboarding" +description = "Enables the complete_onboarding command without any pre-configured scope." +commands.allow = ["complete_onboarding"] + +[[permission]] +identifier = "deny-complete-onboarding" +description = "Denies the complete_onboarding command without any pre-configured scope." +commands.deny = ["complete_onboarding"] diff --git a/src-tauri/permissions/autogenerated/get_autostart.toml b/src-tauri/permissions/autogenerated/get_autostart.toml new file mode 100644 index 0000000..ef7d75a --- /dev/null +++ b/src-tauri/permissions/autogenerated/get_autostart.toml @@ -0,0 +1,11 @@ +# Automatically generated - DO NOT EDIT! + +[[permission]] +identifier = "allow-get-autostart" +description = "Enables the get_autostart command without any pre-configured scope." +commands.allow = ["get_autostart"] + +[[permission]] +identifier = "deny-get-autostart" +description = "Denies the get_autostart command without any pre-configured scope." +commands.deny = ["get_autostart"] diff --git a/src-tauri/permissions/autogenerated/get_hotkey_status.toml b/src-tauri/permissions/autogenerated/get_hotkey_status.toml new file mode 100644 index 0000000..8b2ec51 --- /dev/null +++ b/src-tauri/permissions/autogenerated/get_hotkey_status.toml @@ -0,0 +1,11 @@ +# Automatically generated - DO NOT EDIT! + +[[permission]] +identifier = "allow-get-hotkey-status" +description = "Enables the get_hotkey_status command without any pre-configured scope." +commands.allow = ["get_hotkey_status"] + +[[permission]] +identifier = "deny-get-hotkey-status" +description = "Denies the get_hotkey_status command without any pre-configured scope." +commands.deny = ["get_hotkey_status"] diff --git a/src-tauri/permissions/autogenerated/get_onboarding_state.toml b/src-tauri/permissions/autogenerated/get_onboarding_state.toml new file mode 100644 index 0000000..72d5f1f --- /dev/null +++ b/src-tauri/permissions/autogenerated/get_onboarding_state.toml @@ -0,0 +1,11 @@ +# Automatically generated - DO NOT EDIT! + +[[permission]] +identifier = "allow-get-onboarding-state" +description = "Enables the get_onboarding_state command without any pre-configured scope." +commands.allow = ["get_onboarding_state"] + +[[permission]] +identifier = "deny-get-onboarding-state" +description = "Denies the get_onboarding_state command without any pre-configured scope." +commands.deny = ["get_onboarding_state"] diff --git a/src-tauri/permissions/autogenerated/increment_onboarding_session.toml b/src-tauri/permissions/autogenerated/increment_onboarding_session.toml new file mode 100644 index 0000000..25bb122 --- /dev/null +++ b/src-tauri/permissions/autogenerated/increment_onboarding_session.toml @@ -0,0 +1,11 @@ +# Automatically generated - DO NOT EDIT! + +[[permission]] +identifier = "allow-increment-onboarding-session" +description = "Enables the increment_onboarding_session command without any pre-configured scope." +commands.allow = ["increment_onboarding_session"] + +[[permission]] +identifier = "deny-increment-onboarding-session" +description = "Denies the increment_onboarding_session command without any pre-configured scope." +commands.deny = ["increment_onboarding_session"] diff --git a/src-tauri/permissions/autogenerated/open_accessibility_settings.toml b/src-tauri/permissions/autogenerated/open_accessibility_settings.toml new file mode 100644 index 0000000..e8c340f --- /dev/null +++ b/src-tauri/permissions/autogenerated/open_accessibility_settings.toml @@ -0,0 +1,11 @@ +# Automatically generated - DO NOT EDIT! + +[[permission]] +identifier = "allow-open-accessibility-settings" +description = "Enables the open_accessibility_settings command without any pre-configured scope." +commands.allow = ["open_accessibility_settings"] + +[[permission]] +identifier = "deny-open-accessibility-settings" +description = "Denies the open_accessibility_settings command without any pre-configured scope." +commands.deny = ["open_accessibility_settings"] diff --git a/src-tauri/permissions/autogenerated/set_autostart.toml b/src-tauri/permissions/autogenerated/set_autostart.toml new file mode 100644 index 0000000..ed8c7f5 --- /dev/null +++ b/src-tauri/permissions/autogenerated/set_autostart.toml @@ -0,0 +1,11 @@ +# Automatically generated - DO NOT EDIT! + +[[permission]] +identifier = "allow-set-autostart" +description = "Enables the set_autostart command without any pre-configured scope." +commands.allow = ["set_autostart"] + +[[permission]] +identifier = "deny-set-autostart" +description = "Denies the set_autostart command without any pre-configured scope." +commands.deny = ["set_autostart"] diff --git a/src-tauri/src/commands/accessibility.rs b/src-tauri/src/commands/accessibility.rs new file mode 100644 index 0000000..9c58528 --- /dev/null +++ b/src-tauri/src/commands/accessibility.rs @@ -0,0 +1,25 @@ +//! Thin Tauri command handlers for the macOS accessibility-permission flow +//! (Story 8.2 / FR54). All OS-divergent logic lives behind the [`crate::platform`] +//! abstraction; these handlers only resolve the active platform and delegate. +//! Synchronous (an FFI query / a process spawn) per the project's command +//! convention. On non-macOS platforms the underlying impls report the permission +//! as granted and the settings call is a no-op, so onboarding skips the step. + +use crate::errors::NoteyError; +use crate::platform; + +/// Whether the OS has granted the accessibility permission the global hotkey +/// depends on. Always `Ok(true)` off macOS (no such gate). +#[tauri::command] +#[specta::specta] +pub fn check_accessibility_permission() -> Result { + platform::current().accessibility_permission_granted() +} + +/// Open the OS settings pane where the user grants accessibility permission. +/// No-op off macOS. +#[tauri::command] +#[specta::specta] +pub fn open_accessibility_settings() -> Result<(), NoteyError> { + platform::current().open_accessibility_settings() +} diff --git a/src-tauri/src/commands/autostart.rs b/src-tauri/src/commands/autostart.rs new file mode 100644 index 0000000..04f8f60 --- /dev/null +++ b/src-tauri/src/commands/autostart.rs @@ -0,0 +1,94 @@ +//! Thin Tauri command handlers for auto-start on login (Story 8.4 / FR41–FR43). +//! +//! The OS launch agent is owned by `tauri-plugin-autostart` (registered with +//! `MacosLauncher::LaunchAgent` in `lib.rs`) and reached through the +//! [`crate::platform::Platform`] trait's `autostart_*` methods (DW-97), which +//! delegate to `app.autolaunch()`. The user's preference is the single source of +//! truth at `config.toml` +//! `[general] auto_start`; [`set_autostart`] registers/unregisters the OS agent +//! AND persists the preference atomically under the shared `Mutex`, +//! mirroring [`crate::commands::config::update_config`]'s lock discipline. + +use std::sync::Mutex; + +use tauri::State; + +use crate::errors::NoteyError; +use crate::models::config::AppConfig; +use crate::services; + +use super::config::ConfigDir; +use super::recover_poisoned_config; + +/// Enable/disable auto-start via the plugin, persist atomically, and return committed config. +#[tauri::command] +#[specta::specta] +pub fn set_autostart( + #[allow(unused_variables)] app: tauri::AppHandle, + config_state: State<'_, Mutex>, + config_dir_state: State<'_, ConfigDir>, + enabled: bool, +) -> Result { + // Hold the config mutex across the OS change + persist so a concurrent + // update_config cannot interleave and clobber the stored snapshot. + let mut config = config_state.lock().unwrap_or_else(recover_poisoned_config); + + #[cfg(desktop)] + let rollback_to = { + // Route the OS registration through the Platform trait (DW-97) rather than + // hitting `app.autolaunch()` directly, so the trait is the single source + // of truth for auto-start side effects. + let platform = crate::platform::current(); + let currently_enabled = platform.autostart_is_enabled(&app)?; + + if enabled != currently_enabled { + if enabled { + platform.autostart_enable(&app)?; + } else { + platform.autostart_disable(&app)?; + } + Some(currently_enabled) + } else { + None + } + }; + + // OS registration succeeded (or no change needed) — now persist the preference. + let mut updated = config.clone(); + updated.general.auto_start = enabled; + if let Err(save_err) = services::config::save(&config_dir_state.0, &updated) { + #[cfg(desktop)] + if let Some(previously_enabled) = rollback_to { + let platform = crate::platform::current(); + let rollback = if previously_enabled { + platform.autostart_enable(&app) + } else { + platform.autostart_disable(&app) + }; + if let Err(rollback_err) = rollback { + eprintln!("warning: failed to roll back auto-start after config save failure: {rollback_err}"); + } + } + return Err(save_err); + } + *config = updated; + + Ok(config.clone()) +} + +/// Whether auto-start on login is currently registered at the OS level. +/// Reports the live platform state via the autostart plugin (the source of truth +/// for the *active* registration), letting the UI reconcile its toggle with the +/// real OS state. Off desktop there is no launch agent, so it reports `false`. +#[tauri::command] +#[specta::specta] +pub fn get_autostart(#[allow(unused_variables)] app: tauri::AppHandle) -> Result { + #[cfg(desktop)] + { + crate::platform::current().autostart_is_enabled(&app) + } + #[cfg(not(desktop))] + { + Ok(false) + } +} diff --git a/src-tauri/src/commands/config.rs b/src-tauri/src/commands/config.rs index 8844386..3c6e491 100644 --- a/src-tauri/src/commands/config.rs +++ b/src-tauri/src/commands/config.rs @@ -46,9 +46,9 @@ fn restore_shortcut_registrations( .map_err(|e| NoteyError::Config(format!("Failed to reset shortcut registrations: {e}")))?; if let Some(shortcut) = desired_active { - app.global_shortcut() - .register(shortcut) - .map_err(|e| NoteyError::Config(format!("Failed to restore shortcut registration: {e}")))?; + app.global_shortcut().register(shortcut).map_err(|e| { + NoteyError::Config(format!("Failed to restore shortcut registration: {e}")) + })?; } Ok(()) @@ -131,9 +131,7 @@ pub fn update_config( // unchanged persisted config. #[cfg(desktop)] if registered_new { - if let Err(recovery_error) = - restore_shortcut_registrations(&app, old_active_shortcut) - { + if let Err(recovery_error) = restore_shortcut_registrations(&app, old_active_shortcut) { return Err(NoteyError::Config(format!( "{} (original save error: {})", match recovery_error { @@ -155,16 +153,15 @@ pub fn update_config( if let Some(new_shortcut) = parsed_new_shortcut { if let Some(old_shortcut) = old_active_shortcut { if old_shortcut != new_shortcut { - if let Err(unregister_error) = - app.global_shortcut().unregister(old_shortcut) - { - restore_shortcut_registrations(&app, Some(new_shortcut)) - .map_err(|recovery_error| { + if let Err(unregister_error) = app.global_shortcut().unregister(old_shortcut) { + restore_shortcut_registrations(&app, Some(new_shortcut)).map_err( + |recovery_error| { NoteyError::Config(format!( "Failed to retire previous shortcut: {} (recovery: {})", unregister_error, recovery_error )) - })?; + }, + )?; } } } diff --git a/src-tauri/src/commands/hotkey.rs b/src-tauri/src/commands/hotkey.rs new file mode 100644 index 0000000..21635de --- /dev/null +++ b/src-tauri/src/commands/hotkey.rs @@ -0,0 +1,27 @@ +//! Thin Tauri command exposing the global-shortcut backend status detected at +//! startup (Story 8.6 / FR57, DW-99). +//! +//! `lib.rs` records the outcome of the startup `register_hotkey` probe in +//! managed `Mutex` state; the frontend pulls it on launch via this +//! command and warns the user when the hotkey is unavailable. Synchronous per the +//! project's command convention (a mutex read, no async work). + +use std::sync::Mutex; + +use tauri::State; + +use crate::models::hotkey::HotkeyStatus; + +/// Return the global-shortcut backend status for the current session. +/// +/// Reads the value recorded during startup hotkey detection. A poisoned lock is +/// recovered by cloning the inner value — the status is plain data with no +/// transactional state to repair. +#[tauri::command] +#[specta::specta] +pub fn get_hotkey_status(state: State<'_, Mutex>) -> HotkeyStatus { + state + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()) + .clone() +} diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rs index 17a1358..9073869 100644 --- a/src-tauri/src/commands/mod.rs +++ b/src-tauri/src/commands/mod.rs @@ -1,6 +1,10 @@ +pub mod accessibility; +pub mod autostart; pub mod config; pub mod export; +pub mod hotkey; pub mod notes; +pub mod onboarding; pub mod search; pub mod system; pub mod window; diff --git a/src-tauri/src/commands/onboarding.rs b/src-tauri/src/commands/onboarding.rs new file mode 100644 index 0000000..c314b07 --- /dev/null +++ b/src-tauri/src/commands/onboarding.rs @@ -0,0 +1,34 @@ +//! Thin Tauri command handlers for first-run onboarding state. All logic lives +//! in [`crate::services::onboarding`]; these handlers only resolve the managed +//! config directory and delegate. Synchronous (filesystem-only work) per the +//! project's command convention. + +use tauri::State; + +use crate::errors::NoteyError; +use crate::services::onboarding::{self, OnboardingState}; + +use super::config::ConfigDir; + +/// Returns the persisted onboarding state (completion flag + session count). +#[tauri::command] +#[specta::specta] +pub fn get_onboarding_state( + config_dir: State<'_, ConfigDir>, +) -> Result { + onboarding::load(&config_dir.0) +} + +/// Marks onboarding complete and persists it. Idempotent. +#[tauri::command] +#[specta::specta] +pub fn complete_onboarding(config_dir: State<'_, ConfigDir>) -> Result<(), NoteyError> { + onboarding::mark_complete(&config_dir.0) +} + +/// Increments the persisted session counter and returns the new count. +#[tauri::command] +#[specta::specta] +pub fn increment_onboarding_session(config_dir: State<'_, ConfigDir>) -> Result { + onboarding::increment_session(&config_dir.0) +} diff --git a/src-tauri/src/ipc/events.rs b/src-tauri/src/ipc/events.rs index c00932c..761326a 100644 --- a/src-tauri/src/ipc/events.rs +++ b/src-tauri/src/ipc/events.rs @@ -47,10 +47,28 @@ impl NoteCreated { } } +/// The `hotkey-pressed` event — emitted whenever the registered global capture +/// shortcut fires. +/// +/// First-run onboarding (Story 8.1) dismisses its overlay when the user presses +/// the hotkey, but the OS-level shortcut hides the window without reloading the +/// webview, and a registered global shortcut does not reliably deliver a keydown +/// to the focused page across platforms. The shortcut handler emits this typed +/// event; the visible overlay listens via the generated `events.hotkeyPressed` +/// binding and completes onboarding. It is a marker event with no payload. +#[derive(Debug, Clone, Serialize, Deserialize, Type, Event)] +#[serde(rename_all = "camelCase")] +pub struct HotkeyPressed; + #[cfg(test)] mod tests { use super::*; + #[test] + fn hotkey_pressed_event_name_is_kebab_case() { + assert_eq!(HotkeyPressed::NAME, "hotkey-pressed"); + } + #[test] fn note_created_serializes_camel_case_shape() { let value = serde_json::to_value(NoteCreated::now(42)).expect("serialize"); @@ -58,7 +76,10 @@ mod tests { assert_eq!(value["data"]["noteId"].as_i64(), Some(42)); // Timestamp is present and non-empty (an RFC 3339 string). let ts = value["timestamp"].as_str().expect("timestamp string"); - assert!(!ts.is_empty(), "timestamp must be a non-empty ISO 8601 string"); + assert!( + !ts.is_empty(), + "timestamp must be a non-empty ISO 8601 string" + ); // No snake_case leakage. assert!(value["data"].get("note_id").is_none()); } diff --git a/src-tauri/src/ipc/protocol.rs b/src-tauri/src/ipc/protocol.rs index ee0c761..8859b8c 100644 --- a/src-tauri/src/ipc/protocol.rs +++ b/src-tauri/src/ipc/protocol.rs @@ -402,7 +402,10 @@ mod tests { .to_string(); let filtered = handle_request( &conn, - &request("list_notes", serde_json::json!({ "workspaceName": ws_name })), + &request( + "list_notes", + serde_json::json!({ "workspaceName": ws_name }), + ), ); assert!(filtered.success); let rows = filtered.data.unwrap(); @@ -414,7 +417,10 @@ mod tests { // A non-existent workspace name → empty. let none = handle_request( &conn, - &request("list_notes", serde_json::json!({ "workspaceName": "no-such-ws" })), + &request( + "list_notes", + serde_json::json!({ "workspaceName": "no-such-ws" }), + ), ); assert!(none.success); assert!(none.data.unwrap().as_array().unwrap().is_empty()); @@ -499,7 +505,10 @@ mod tests { let resp = IpcResponse::ok(serde_json::json!({ "title": "x" })); assert_eq!(created_note_id(&raw, &resp), None); // Unparseable request bytes never panic. - assert_eq!(created_note_id(b"{not json", &IpcResponse::ok(Value::Null)), None); + assert_eq!( + created_note_id(b"{not json", &IpcResponse::ok(Value::Null)), + None + ); } #[test] diff --git a/src-tauri/src/ipc/socket_server.rs b/src-tauri/src/ipc/socket_server.rs index 9441205..203dae3 100644 --- a/src-tauri/src/ipc/socket_server.rs +++ b/src-tauri/src/ipc/socket_server.rs @@ -106,59 +106,57 @@ type WorkerRegistry = Arc>>; /// it ultimately calls [`handle_request`]. pub type Handler = Arc IpcResponse + Send + Sync>; -/// Resolve the per-user socket path. +/// Scan an argument iterator for a `--socket-path ` (or +/// `--socket-path=`) override, returning the first non-empty value. /// -/// Honors the `NOTEY_SOCKET_PATH` override first (the testability seam). On Unix, -/// prefers `$XDG_RUNTIME_DIR/notey.sock`, falling back to a user-scoped temp-dir -/// path. On Windows, returns a user-scoped namespaced pipe name. -pub fn socket_path() -> PathBuf { - if let Ok(custom) = std::env::var("NOTEY_SOCKET_PATH") { - return PathBuf::from(custom); +/// Parsed permissively so the desktop app never aborts on flags injected by its +/// launcher (e.g. a WebDriver harness forwarding `tauri:options.args`): unknown +/// arguments are ignored, and a flag with a missing or empty value is treated as +/// absent (falls through to env/default) rather than an error. +fn socket_path_arg_from>(args: I) -> Option { + let mut args = args; + while let Some(arg) = args.next() { + if let Some(value) = arg.strip_prefix("--socket-path=") { + if !value.is_empty() { + return Some(PathBuf::from(value)); + } + continue; + } + if arg == "--socket-path" { + let Some(value) = args.next() else { + continue; + }; + if !value.is_empty() && !value.starts_with("--") { + return Some(PathBuf::from(value)); + } + } } + None +} - #[cfg(unix)] - { - if let Some(dir) = dirs::runtime_dir() { - return dir.join("notey.sock"); - } - let file_name = user_scope_token() - .map(|token| format!("notey-{token}.sock")) - .unwrap_or_else(|| "notey.sock".to_string()); - std::env::temp_dir().join(file_name) +/// Read the `--socket-path` override from this process's actual arguments. +fn socket_path_arg() -> Option { + socket_path_arg_from(std::env::args()) +} + +/// Resolve the per-user socket path. +/// +/// Precedence: an explicit `--socket-path` CLI argument wins (the channel the +/// E2E harness routes through `tauri:options.args`, since it survives a launcher +/// that resets the environment), then the `NOTEY_SOCKET_PATH` env override (the +/// testability seam). Otherwise it delegates to the platform abstraction's +/// [`crate::platform::Platform::socket_path`], the single source of truth for the +/// default per-user path (Story 8.5). +pub fn socket_path() -> PathBuf { + if let Some(custom) = socket_path_arg() { + return custom; } - #[cfg(windows)] - { - PathBuf::from( - user_scope_token() - .map(|token| format!("notey-{token}")) - .unwrap_or_else(|| "notey".to_string()), - ) + if let Ok(custom) = std::env::var("NOTEY_SOCKET_PATH") { + return PathBuf::from(custom); } -} -fn user_scope_token() -> Option { - dirs::home_dir() - .as_deref() - .and_then(Path::file_name) - .and_then(|name| name.to_str()) - .map(str::to_owned) - .or_else(|| std::env::var("USER").ok()) - .or_else(|| std::env::var("USERNAME").ok()) - .and_then(|candidate| { - let sanitized: String = candidate - .chars() - .map(|c| { - if c.is_ascii_alphanumeric() { - c.to_ascii_lowercase() - } else { - '-' - } - }) - .collect(); - let trimmed = sanitized.trim_matches('-'); - (!trimmed.is_empty()).then(|| trimmed.to_string()) - }) + crate::platform::current().socket_path() } /// Build the transport `Name` for `path`: a filesystem socket on Unix, a @@ -166,16 +164,15 @@ fn user_scope_token() -> Option { fn to_name(path: &Path) -> io::Result> { #[cfg(windows)] { - let raw = path - .file_name() - .unwrap_or(path.as_os_str()) - .to_owned(); + let raw = path.file_name().unwrap_or(path.as_os_str()).to_owned(); raw.to_ns_name::() } #[cfg(not(windows))] { - path.as_os_str().to_owned().to_fs_name::() + path.as_os_str() + .to_owned() + .to_fs_name::() } } @@ -587,3 +584,98 @@ fn reaper_loop(shutdown: Arc, registry: WorkerRegistry) { drop(reg); } } + +#[cfg(test)] +mod tests { + use super::*; + + /// Build an owned-`String` argument iterator from string literals, mirroring + /// what `std::env::args()` yields (the program name is included as argv[0]). + fn argv(items: &[&str]) -> std::vec::IntoIter { + items + .iter() + .map(|s| s.to_string()) + .collect::>() + .into_iter() + } + + #[test] + fn socket_path_arg_space_form() { + let got = socket_path_arg_from(argv(&["notey", "--socket-path", "/tmp/x.sock"])); + assert_eq!(got, Some(PathBuf::from("/tmp/x.sock"))); + } + + #[test] + fn socket_path_arg_equals_form() { + let got = socket_path_arg_from(argv(&["notey", "--socket-path=/tmp/x.sock"])); + assert_eq!(got, Some(PathBuf::from("/tmp/x.sock"))); + } + + #[test] + fn socket_path_arg_missing_value_is_absent() { + // Flag is the final token with no value following it. + let got = socket_path_arg_from(argv(&["notey", "--socket-path"])); + assert_eq!(got, None); + } + + #[test] + fn socket_path_arg_missing_value_before_unknown_flag_is_absent() { + let got = socket_path_arg_from(argv(&["notey", "--socket-path", "--unrelated"])); + assert_eq!(got, None); + } + + #[test] + fn socket_path_arg_empty_value_is_absent() { + assert_eq!( + socket_path_arg_from(argv(&["notey", "--socket-path="])), + None + ); + assert_eq!( + socket_path_arg_from(argv(&["notey", "--socket-path", ""])), + None + ); + } + + #[test] + fn socket_path_arg_skips_empty_value_and_keeps_scanning() { + let got = socket_path_arg_from(argv(&[ + "notey", + "--socket-path=", + "--socket-path", + "/tmp/x.sock", + ])); + assert_eq!(got, Some(PathBuf::from("/tmp/x.sock"))); + } + + #[test] + fn socket_path_arg_ignores_unknown_extra_args() { + let got = socket_path_arg_from(argv(&[ + "notey", + "--unrelated", + "value", + "--socket-path", + "/tmp/x.sock", + "--another", + ])); + assert_eq!(got, Some(PathBuf::from("/tmp/x.sock"))); + } + + #[test] + fn socket_path_arg_absent() { + let got = socket_path_arg_from(argv(&["notey", "--unrelated", "value"])); + assert_eq!(got, None); + } + + #[test] + fn socket_path_arg_first_occurrence_wins() { + // Defensive: a duplicated flag resolves to the first value, not the last. + let got = socket_path_arg_from(argv(&[ + "notey", + "--socket-path", + "/tmp/first.sock", + "--socket-path", + "/tmp/second.sock", + ])); + assert_eq!(got, Some(PathBuf::from("/tmp/first.sock"))); + } +} diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs index acc861d..e93b18f 100644 --- a/src-tauri/src/lib.rs +++ b/src-tauri/src/lib.rs @@ -18,32 +18,43 @@ use crate::commands::config::ConfigDir; fn specta_builder() -> tauri_specta::Builder { tauri_specta::Builder::::new() - .events(collect_events![ipc::events::NoteCreated]) + .events(collect_events![ + ipc::events::NoteCreated, + ipc::events::HotkeyPressed + ]) .commands(collect_commands![ - commands::notes::create_note, - commands::notes::get_note, - commands::notes::update_note, - commands::notes::trash_note, - commands::notes::restore_note, - commands::notes::list_trashed_notes, - commands::notes::delete_note_permanently, - commands::notes::list_notes, - commands::notes::reassign_note_workspace, - commands::notes::rebuild_fts_index, - commands::config::get_config, - commands::config::update_config, - commands::window::dismiss_window, - commands::window::apply_layout_mode, - commands::workspace::create_workspace, - commands::workspace::list_workspaces, - commands::workspace::get_workspace, - commands::workspace::detect_workspace, - commands::workspace::resolve_workspace, - commands::system::get_current_dir, - commands::search::search_notes, - commands::export::export_markdown, - commands::export::export_json, - ]) + commands::notes::create_note, + commands::notes::get_note, + commands::notes::update_note, + commands::notes::trash_note, + commands::notes::restore_note, + commands::notes::list_trashed_notes, + commands::notes::delete_note_permanently, + commands::notes::list_notes, + commands::notes::reassign_note_workspace, + commands::notes::rebuild_fts_index, + commands::config::get_config, + commands::config::update_config, + commands::onboarding::get_onboarding_state, + commands::onboarding::complete_onboarding, + commands::onboarding::increment_onboarding_session, + commands::accessibility::check_accessibility_permission, + commands::accessibility::open_accessibility_settings, + commands::autostart::set_autostart, + commands::autostart::get_autostart, + commands::window::dismiss_window, + commands::window::apply_layout_mode, + commands::workspace::create_workspace, + commands::workspace::list_workspaces, + commands::workspace::get_workspace, + commands::workspace::detect_workspace, + commands::workspace::resolve_workspace, + commands::system::get_current_dir, + commands::search::search_notes, + commands::export::export_markdown, + commands::export::export_json, + commands::hotkey::get_hotkey_status, + ]) } /// Toggles the main window: shows + centers + focuses if hidden, hides if visible. @@ -150,6 +161,12 @@ pub fn run() { tauri::Builder::default() .plugin(tauri_plugin_opener::init()) .plugin(tauri_plugin_dialog::init()) + // Auto-start on login (Story 8.4). LaunchAgent is the macOS mechanism; no + // extra launch args. The plugin exposes app.autolaunch() (ManagerExt). + .plugin(tauri_plugin_autostart::init( + tauri_plugin_autostart::MacosLauncher::LaunchAgent, + Some(vec![]), + )) .invoke_handler(builder.invoke_handler()) .setup(move |app| { // Register typed tauri-specta events (e.g. `note-created`) into the @@ -157,10 +174,12 @@ pub fn run() { builder.mount_events(app); // --- Database --- - let data_dir = app - .path() - .app_data_dir() - .expect("Failed to get app data dir"); + // Resolve the per-user data directory through the Platform abstraction + // (Story 8.5) so data-path isolation has a single source of truth + // rather than Tauri's bundle-id-based default. + let data_dir = crate::platform::current() + .data_dir() + .expect("Failed to resolve data dir"); let conn = db::init_db(data_dir).expect("Failed to initialize database"); app.manage(Mutex::new(conn)); @@ -186,9 +205,59 @@ pub fn run() { } } + // --- First-run onboarding: reveal the window so the overlay shows --- + // The main window is created hidden and is normally summoned via the + // global shortcut. On first run (onboarding not yet completed) we show + // it at startup so the OnboardingOverlay greets the user. A read failure + // is non-fatal — fall back to the default hidden-until-summoned behavior. + let first_run = !services::onboarding::is_complete(&config_dir).unwrap_or(false); + if first_run { + if let Some(window) = app.get_webview_window("main") { + let _ = window.center(); + let _ = window.show(); + let _ = window.set_focus(); + } + } + + // --- Auto-start on login: reconcile OS registration to the saved + // preference (Story 8.4 / FR43). The persisted `[general] auto_start` + // is the source of truth; aligning the launch agent on every startup + // ensures a reboot relaunches Notey when enabled (and that an + // externally-removed agent is restored). Best-effort and non-fatal — + // a plugin failure must never block startup. + #[cfg(desktop)] + { + // Route through the Platform trait (DW-97) so auto-start side + // effects have a single source of truth; the trait delegates to + // `tauri-plugin-autostart`. + let desired = config.general.auto_start; + let platform = crate::platform::current(); + let handle = app.handle(); + match platform.autostart_is_enabled(handle) { + Ok(active) if active != desired => { + let outcome = if desired { + platform.autostart_enable(handle) + } else { + platform.autostart_disable(handle) + }; + if let Err(e) = outcome { + eprintln!("warning: failed to reconcile auto-start to {desired}: {e}"); + } + } + Ok(_) => {} + Err(e) => eprintln!("warning: failed to query auto-start state: {e}"), + } + } + app.manage(Mutex::new(config)); app.manage(ConfigDir(config_dir)); + // Hotkey backend status (Story 8.6 / FR57, DW-99). Managed + // unconditionally so `get_hotkey_status` always resolves, including on + // builds where the desktop shortcut block below is compiled out. + // Defaults to available; the detection arm updates it on a backend miss. + app.manage(Mutex::new(models::hotkey::HotkeyStatus::available())); + // --- Global shortcut --- #[cfg(desktop)] { @@ -200,8 +269,7 @@ pub fn run() { "Warning: invalid shortcut '{}', falling back to {}", shortcut_str, default_shortcut ); - parse_shortcut(&default_shortcut) - .expect("platform default shortcut must parse") + parse_shortcut(&default_shortcut).expect("platform default shortcut must parse") }); let app_handle = app.handle().clone(); @@ -213,19 +281,55 @@ pub fn run() { // value when the hotkey is re-registered via update_config. if event.state() == ShortcutState::Pressed { toggle_main_window(&app_handle); + // Notify the webview so the first-run onboarding overlay + // can complete on hotkey press (Story 8.1). Best-effort: + // a failed emit must not affect window toggling. + let _ = ipc::events::HotkeyPressed.emit(&app_handle); } }) .build(), )?; - // Non-fatal: a saved shortcut that conflicts with another app - // must not brick startup. Log and continue — the window stays - // summonable via the tray and the user can rebind in Settings. - if let Err(e) = app.global_shortcut().register(shortcut) { - eprintln!( - "Warning: failed to register global shortcut '{}': {}", - shortcut_str, e - ); + // Story 8.6 / FR57: consult the Platform abstraction for the + // hotkey backend available on this session before registering. + // On a compositor with no usable backend (pure Wayland without + // XWayland — native portal support is a fast-follow, DW-96) it + // returns Err; notify the user and skip the initial registration. + // The plugin/handler above stays installed so a later rebind via + // update_config can still register, and the window remains + // summonable from the tray. + match crate::platform::current().register_hotkey(&shortcut_str) { + Ok(_backend) => { + *app.state::>() + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()) = + models::hotkey::HotkeyStatus::available(); + + // Non-fatal: a saved shortcut that conflicts with another + // app must not brick startup. Log and continue — the + // window stays summonable via the tray and the user can + // rebind in Settings. + if let Err(e) = app.global_shortcut().register(shortcut) { + eprintln!( + "Warning: failed to register global shortcut '{}': {}", + shortcut_str, e + ); + } + } + Err(e) => { + eprintln!( + "Notice: global shortcut unavailable on this compositor ({e}); \ + summon Notey from the tray icon instead." + ); + // Record the miss so the frontend can pull it on startup and + // warn the user the hotkey will not work (Story 8.6 / FR57, + // DW-99). The managed default is `available()`, so only the + // unavailable case needs to overwrite it. + *app.state::>() + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()) = + models::hotkey::HotkeyStatus::unavailable(e.to_string()); + } } } @@ -285,8 +389,7 @@ pub fn run() { std::sync::Arc::new(move |raw: &[u8]| { let response = { let state = app_handle.state::>(); - let conn = - state.lock().unwrap_or_else(commands::recover_poisoned_db); + let conn = state.lock().unwrap_or_else(commands::recover_poisoned_db); ipc::protocol::handle_request(&conn, raw) // conn guard dropped here, before emitting. }; @@ -349,7 +452,15 @@ mod tests { #[test] fn parse_shortcut_accepts_modifier_aliases() { // Each spelling of a modifier resolves; same combo parses every way. - for s in ["Ctrl+N", "Control+N", "Cmd+N", "Command+N", "Super+N", "Meta+N", "Alt+N"] { + for s in [ + "Ctrl+N", + "Control+N", + "Cmd+N", + "Command+N", + "Super+N", + "Meta+N", + "Alt+N", + ] { assert!(parse_shortcut(s).is_some(), "expected '{s}' to parse"); } } diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs index 2abccd9..531f025 100644 --- a/src-tauri/src/main.rs +++ b/src-tauri/src/main.rs @@ -2,5 +2,5 @@ #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] fn main() { - tauri_app_lib::run() + notey_lib::run() } diff --git a/src-tauri/src/models/config.rs b/src-tauri/src/models/config.rs index 950305d..8dd978a 100644 --- a/src-tauri/src/models/config.rs +++ b/src-tauri/src/models/config.rs @@ -37,15 +37,21 @@ pub enum Theme { } /// General application settings. -/// /// `theme` is one of `system` (the default — follow the OS `prefers-color-scheme` /// until the user picks a theme), `dark`, or `light`. A saved manual `dark`/`light` /// preference overrides the OS setting on restart. +/// `auto_start` (serialized `[general] autoStart`) is the persisted auto-start-on-login +/// preference (Story 8.4 / FR41–FR43). It defaults to `false` and tolerates a missing +/// key on older config files via serde. The OS launch agent is managed by +/// `tauri-plugin-autostart`; this field is the single source of truth the app +/// reconciles the OS registration to on every startup. #[derive(Debug, Clone, Serialize, Deserialize, Type)] #[serde(rename_all = "camelCase")] pub struct GeneralConfig { pub theme: Theme, pub layout_mode: String, + #[serde(default, alias = "auto_start")] + pub auto_start: bool, } /// Editor-specific settings. @@ -170,6 +176,8 @@ impl Default for GeneralConfig { // The default window mode (Story 7.5). `floating` is the always-on-top // 600×400 capture overlay — the app's primary form factor. layout_mode: "floating".to_string(), + // Auto-start on login is opt-in (Story 8.4). + auto_start: false, } } } @@ -220,4 +228,34 @@ mod tests { assert_eq!(config.shortcuts.command_palette, "Ctrl+P"); assert_eq!(config.shortcuts.close_tab, "Ctrl+W"); } + + #[test] + fn auto_start_defaults_to_false() { + // Story 8.4: a fresh install has auto-start opt-in (disabled). + assert!(!AppConfig::default().general.auto_start); + } + + #[test] + fn auto_start_roundtrips_and_tolerates_missing_key() { + // A config without the key deserializes to the false default (serde default). + let without: AppConfig = + toml::from_str("[general]\ntheme = \"dark\"\nlayoutMode = \"floating\"\n").unwrap(); + assert!(!without.general.auto_start); + + // The approved story text uses the Rust/TOML spelling in some places; accept it + // for hand-edited configs while keeping the existing camelCase emitted schema. + let snake_case: AppConfig = toml::from_str( + "[general]\ntheme = \"dark\"\nlayoutMode = \"floating\"\nauto_start = true\n", + ) + .unwrap(); + assert!(snake_case.general.auto_start); + + // An explicit `true` round-trips through serialize → deserialize. + let mut cfg = AppConfig::default(); + cfg.general.auto_start = true; + let serialized = toml::to_string(&cfg).unwrap(); + assert!(serialized.contains("autoStart = true")); + let parsed: AppConfig = toml::from_str(&serialized).unwrap(); + assert!(parsed.general.auto_start); + } } diff --git a/src-tauri/src/models/hotkey.rs b/src-tauri/src/models/hotkey.rs new file mode 100644 index 0000000..451dffa --- /dev/null +++ b/src-tauri/src/models/hotkey.rs @@ -0,0 +1,77 @@ +//! Runtime status of the global-shortcut backend, surfaced to the frontend. +//! +//! Story 8.6 / FR57 detects, at startup, whether the session has a usable +//! global-shortcut backend (a pure Wayland session without XWayland and without +//! native portal support has none — see `lib.rs`). This model records that +//! outcome in Tauri-managed state so the frontend can pull it on launch and warn +//! the user that the hotkey will not work (DW-99). +//! +//! Pulled rather than pushed because the detection runs in the synchronous +//! `setup` hook, long before the (startup-hidden) webview attaches an event +//! listener — a `setup`-time event would be dropped. + +use serde::{Deserialize, Serialize}; +use specta::Type; + +/// Availability of the global-shortcut backend for the current session. +/// +/// Wire shape (camelCase): `{ "available": false, "reason": "" }`. +#[derive(Debug, Clone, Serialize, Deserialize, Type)] +#[serde(rename_all = "camelCase")] +pub struct HotkeyStatus { + /// `true` when a usable global-shortcut backend was found at startup. + pub available: bool, + /// Human-readable reason the backend is unavailable, when `available` is + /// `false`. `None` when the hotkey is available. + pub reason: Option, +} + +impl HotkeyStatus { + /// A status indicating the global-shortcut backend is available. + pub fn available() -> Self { + Self { + available: true, + reason: None, + } + } + + /// A status indicating the backend is unavailable, carrying the technical + /// `reason` for logging (not shown verbatim to the user). + pub fn unavailable(reason: impl Into) -> Self { + Self { + available: false, + reason: Some(reason.into()), + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn available_has_no_reason() { + let status = HotkeyStatus::available(); + assert!(status.available); + assert!(status.reason.is_none()); + } + + #[test] + fn unavailable_carries_reason() { + let status = HotkeyStatus::unavailable("no portal"); + assert!(!status.available); + assert_eq!(status.reason.as_deref(), Some("no portal")); + } + + #[test] + fn serializes_camel_case_shape() { + let value = serde_json::to_value(HotkeyStatus::unavailable("boom")).expect("serialize"); + // camelCase field names, no snake_case leakage. + assert_eq!(value["available"].as_bool(), Some(false)); + assert_eq!(value["reason"].as_str(), Some("boom")); + // `available` true omits the reason as JSON null. + let ok = serde_json::to_value(HotkeyStatus::available()).expect("serialize"); + assert_eq!(ok["available"].as_bool(), Some(true)); + assert!(ok["reason"].is_null()); + } +} diff --git a/src-tauri/src/models/mod.rs b/src-tauri/src/models/mod.rs index c4e4c77..e05fdbc 100644 --- a/src-tauri/src/models/mod.rs +++ b/src-tauri/src/models/mod.rs @@ -1,4 +1,5 @@ pub mod config; +pub mod hotkey; pub mod workspace; use serde::{Deserialize, Serialize}; diff --git a/src-tauri/src/platform/linux.rs b/src-tauri/src/platform/linux.rs index 5df9417..2db2edd 100644 --- a/src-tauri/src/platform/linux.rs +++ b/src-tauri/src/platform/linux.rs @@ -1,12 +1,15 @@ -//! Linux [`Platform`] implementation (X11 + Wayland). RED-PHASE STUB (Story 8.6). +//! Linux [`Platform`] implementation (X11 + Wayland). Paths + hotkey backend +//! selection (Stories 8.5/8.6) and `autostart_*` (DW-97, delegated to +//! `tauri-plugin-autostart` via the shared helpers in [`super`]) are implemented. use std::path::PathBuf; use crate::errors::NoteyError; use crate::platform::{HotkeyBackend, Platform}; -/// Linux platform behavior. Hotkey registration prefers the standard plugin and -/// falls back to the XDG GlobalShortcuts portal under Wayland (FR57). +/// Linux platform behavior. Hotkey backend selection uses the standard plugin +/// when X11/XWayland is available and reports pure Wayland as unavailable until +/// native portal support lands in DW-96. #[derive(Debug, Default)] pub struct LinuxPlatform; @@ -22,35 +25,71 @@ impl Platform for LinuxPlatform { } fn data_dir(&self) -> Result { - todo!("Story 8.5: $XDG_DATA_HOME/notey (per-user)") + // $XDG_DATA_HOME/notey (or ~/.local/share/notey), per-user (Story 8.5). + super::resolve_data_dir("notey") } fn config_dir(&self) -> Result { - todo!("Story 8.6: $XDG_CONFIG_HOME/notey") + // $XDG_CONFIG_HOME/notey (or ~/.config/notey), per-user (Story 8.6). + super::resolve_config_dir("notey") } fn log_dir(&self) -> Result { - todo!("Story 8.6: $XDG_STATE_HOME/notey/logs") + // $XDG_STATE_HOME/notey/logs (or ~/.local/state/notey/logs), per-user (8.6). + dirs::state_dir() + .map(|base| base.join("notey").join("logs")) + .ok_or_else(|| { + NoteyError::Config("Could not determine platform state directory".to_string()) + }) } fn socket_path(&self) -> PathBuf { - todo!("Story 8.5: $XDG_RUNTIME_DIR/notey.sock (per-user, 0600)") + // $XDG_RUNTIME_DIR/notey.sock (per-user; bound 0600 by socket_server). 8.5. + super::resolve_unix_socket() } - fn register_hotkey(&self, accelerator: &str) -> Result { - todo!("Story 8.6: standard plugin, Wayland portal fallback for {accelerator}") + fn register_hotkey(&self, _accelerator: &str) -> Result { + // Story 8.6 / FR57: select the hotkey backend for this Linux session. The + // actual Tauri plugin registration stays in `lib.rs` (it needs the + // AppHandle); this only validates which backend can serve the shortcut. + // + // v1 contract: XWayland is the baseline fallback. The standard + // (X11-based) backend works on X11 natively and on Wayland whenever + // XWayland is present (`DISPLAY` set). A pure-Wayland session with no + // XWayland cannot use the X11 path; native portal support is a fast-follow + // (DW-96), so report the shortcut as unavailable and let the caller notify + // the user (FR57) rather than returning `HotkeyBackend::WaylandPortal`. + let wayland_display = std::env::var_os("WAYLAND_DISPLAY") + .map(|value| !value.is_empty()) + .unwrap_or(false); + let wayland = wayland_display + || std::env::var("XDG_SESSION_TYPE") + .map(|t| t == "wayland") + .unwrap_or(false); + let xwayland = std::env::var_os("DISPLAY") + .map(|value| !value.is_empty()) + .unwrap_or(false); + if wayland && !xwayland { + return Err(NoteyError::Config( + "global shortcut unavailable: Wayland compositor without XWayland \ + (native portal support is a fast-follow — DW-96)" + .to_string(), + )); + } + Ok(HotkeyBackend::Standard) } - fn autostart_enable(&self) -> Result<(), NoteyError> { - todo!("Story 8.4: write XDG autostart .desktop entry") + fn autostart_enable(&self, app: &tauri::AppHandle) -> Result<(), NoteyError> { + // DW-97: delegate to the shared tauri-plugin-autostart helper (Story 8.4). + super::autostart_enable(app) } - fn autostart_disable(&self) -> Result<(), NoteyError> { - todo!("Story 8.4: remove XDG autostart .desktop entry") + fn autostart_disable(&self, app: &tauri::AppHandle) -> Result<(), NoteyError> { + super::autostart_disable(app) } - fn autostart_is_enabled(&self) -> Result { - todo!("Story 8.4: check for the XDG autostart .desktop entry") + fn autostart_is_enabled(&self, app: &tauri::AppHandle) -> Result { + super::autostart_is_enabled(app) } fn accessibility_permission_granted(&self) -> Result { diff --git a/src-tauri/src/platform/macos.rs b/src-tauri/src/platform/macos.rs index ee3ca17..17c72d3 100644 --- a/src-tauri/src/platform/macos.rs +++ b/src-tauri/src/platform/macos.rs @@ -1,6 +1,8 @@ -//! macOS [`Platform`] implementation. RED-PHASE STUB (Stories 8.2, 8.6). +//! macOS [`Platform`] implementation. Accessibility-permission methods (Story 8.2), +//! paths/hotkey-backend selection (Stories 8.5/8.6), and `autostart_*` (DW-97 — +//! delegated to `tauri-plugin-autostart`'s `LaunchAgent`) are implemented. -use std::path::PathBuf; +use std::{io, path::PathBuf}; use crate::errors::NoteyError; use crate::platform::{HotkeyBackend, Platform}; @@ -22,44 +24,82 @@ impl Platform for MacosPlatform { } fn data_dir(&self) -> Result { - todo!("Story 8.5: ~/Library/Application Support/com.notey.app (per-user)") + // ~/Library/Application Support/com.notey.app, per-user (Story 8.5). + super::resolve_data_dir("com.notey.app") } fn config_dir(&self) -> Result { - todo!("Story 8.6: ~/Library/Application Support/com.notey.app") + // ~/Library/Application Support/com.notey.app, per-user (Story 8.6). + super::resolve_config_dir("com.notey.app") } fn log_dir(&self) -> Result { - todo!("Story 8.6: ~/Library/Logs/com.notey.app") + // ~/Library/Logs/com.notey.app, per-user (Story 8.6). `dirs` has no + // dedicated logs dir on macOS, so derive it from the home directory. + dirs::home_dir() + .map(|home| home.join("Library").join("Logs").join("com.notey.app")) + .ok_or_else(|| { + NoteyError::Config("Could not determine home directory for logs".to_string()) + }) } fn socket_path(&self) -> PathBuf { - todo!("Story 8.5: user-scoped temp-dir socket (per-user, 0600)") + // $XDG_RUNTIME_DIR/notey.sock or user-scoped temp fallback; bound 0600 + // by socket_server (Story 8.5). + super::resolve_unix_socket() } - fn register_hotkey(&self, accelerator: &str) -> Result { - todo!("Story 8.6: standard plugin registration for {accelerator}") + fn register_hotkey(&self, _accelerator: &str) -> Result { + // Story 8.6: macOS has a single global-shortcut backend (the standard + // plugin). The actual registration happens in `lib.rs`; this only reports + // the backend. (The Accessibility-permission gate is handled separately + // via `accessibility_permission_granted`, Story 8.2.) + Ok(HotkeyBackend::Standard) } - fn autostart_enable(&self) -> Result<(), NoteyError> { - todo!("Story 8.4: install LaunchAgent plist") + fn autostart_enable(&self, app: &tauri::AppHandle) -> Result<(), NoteyError> { + // DW-97: delegate to the shared tauri-plugin-autostart helper. The plugin + // is registered with MacosLauncher::LaunchAgent in lib.rs (Story 8.4). + super::autostart_enable(app) } - fn autostart_disable(&self) -> Result<(), NoteyError> { - todo!("Story 8.4: remove LaunchAgent plist") + fn autostart_disable(&self, app: &tauri::AppHandle) -> Result<(), NoteyError> { + super::autostart_disable(app) } - fn autostart_is_enabled(&self) -> Result { - todo!("Story 8.4: check for the LaunchAgent plist") + fn autostart_is_enabled(&self, app: &tauri::AppHandle) -> Result { + super::autostart_is_enabled(app) } fn accessibility_permission_granted(&self) -> Result { - todo!("Story 8.2: query AXIsProcessTrusted()") + // `AXIsProcessTrusted` reports whether the app is allowed to use the + // Accessibility APIs the global hotkey depends on (Story 8.2 / FR54). It + // returns CoreFoundation's `Boolean` (an `unsigned char`), so bind it as + // `u8` and compare — a Rust `bool` would be UB for any byte other than + // 0/1. The call is side-effect-free and never blocks. + #[link(name = "ApplicationServices", kind = "framework")] + extern "C" { + fn AXIsProcessTrusted() -> u8; + } + Ok(unsafe { AXIsProcessTrusted() } != 0) } fn open_accessibility_settings(&self) -> Result<(), NoteyError> { - todo!( - "Story 8.2: open x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility" - ) + // Deep-link straight to System Settings > Privacy & Security > + // Accessibility. `open` hands the URL to LaunchServices and exits + // quickly; wait for that short-lived helper so failures are reported and + // the child process is reaped. + let status = std::process::Command::new("open") + .arg("x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility") + .status() + .map_err(NoteyError::Io)?; + + if status.success() { + Ok(()) + } else { + Err(NoteyError::Io(io::Error::other(format!( + "open accessibility settings exited with {status}" + )))) + } } } diff --git a/src-tauri/src/platform/mod.rs b/src-tauri/src/platform/mod.rs index 52a2306..01c756f 100644 --- a/src-tauri/src/platform/mod.rs +++ b/src-tauri/src/platform/mod.rs @@ -1,23 +1,31 @@ //! Cross-platform abstraction over OS-specific behavior: standard paths, global -//! hotkey registration (with a Wayland fallback on Linux), auto-start, and the -//! macOS accessibility-permission flow. +//! hotkey backend selection, auto-start, and the macOS accessibility-permission +//! flow. //! -//! **RED-PHASE STUB (Epic 8 — Stories 8.2, 8.5, 8.6).** The [`Platform`] trait -//! defines the contract; the per-OS implementations in [`linux`], [`macos`], and -//! [`windows`] are unimplemented scaffolds (`todo!`). Acceptance tests live in -//! `tests/platform_tests.rs`, marked `#[ignore = "red-phase: Story 8.x"]`. +//! **Story 8.5 (done):** `data_dir` and `socket_path` are implemented for all +//! three targets via the shared resolvers below; the DB location (`lib.rs`) and +//! `crate::ipc::socket_server::socket_path` route through this trait so per-user +//! isolation has a single source of truth. //! -//! ## Green-phase wiring (do this when implementing) -//! - Implement each `#[cfg(target_os = ...)]` struct against the real OS APIs. -//! - Linux `register_hotkey`: try the standard Tauri global-shortcut plugin first; -//! on failure under Wayland, attempt the XDG GlobalShortcuts portal (verify the -//! current `ashpd` version on crates.io — do not pin from memory); if neither -//! works, return [`NoteyError::Config`] so the caller can notify the user (FR57). -//! - Route `crate::ipc::socket_server::socket_path` and the DB/config dir helpers -//! through this trait so per-user isolation (Story 8.5) has a single source of -//! truth. - -use std::path::PathBuf; +//! **Story 8.6 (done):** `config_dir`, `log_dir`, and `register_hotkey` are +//! implemented for all three targets. `services::config::config_dir` now +//! delegates to this trait so config-path resolution has a single source of +//! truth, and `lib.rs` consults `register_hotkey` to detect a compositor with no +//! usable hotkey backend (pure Wayland without XWayland) and degrade gracefully +//! (FR56/FR57/FR58). +//! +//! **DW-97 (done):** the `autostart_*` methods are implemented for all three +//! targets. Their signatures take the Tauri `AppHandle` so they can reach +//! `tauri-plugin-autostart` (`app.autolaunch()`), which owns the per-OS +//! launch-agent mechanism. Each per-OS impl delegates to the shared +//! `autostart_*` helpers below (one place to call the plugin, no per-OS +//! reimplementation), and `commands::autostart` + the `lib.rs` startup reconcile +//! now route through this trait so auto-start side effects have a single source +//! of truth. Still deferred: the native Wayland `ashpd` GlobalShortcuts portal +//! (fast-follow, DW-96; `register_hotkey` returns `Err` on such sessions rather +//! than `HotkeyBackend::WaylandPortal`). + +use std::path::{Path, PathBuf}; use crate::errors::NoteyError; @@ -30,8 +38,8 @@ pub mod windows; /// Which mechanism satisfied a global-hotkey registration request. /// -/// Distinguishing the path taken lets the UI explain a degraded experience on -/// compositors where only the portal works (Story 8.6 / FR57). +/// Distinguishing the path taken lets callers explain degraded hotkey support +/// when a compositor cannot use the standard backend (Story 8.6 / FR57). #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum HotkeyBackend { /// The standard Tauri global-shortcut plugin (X11, macOS, Windows). @@ -59,18 +67,27 @@ pub trait Platform: Send + Sync { fn socket_path(&self) -> PathBuf; /// Register the global capture hotkey, returning which backend served it. - /// Linux attempts [`HotkeyBackend::WaylandPortal`] when the standard plugin - /// fails under Wayland (FR57). + /// Linux returns [`HotkeyBackend::Standard`] when X11/XWayland is available + /// and [`NoteyError::Config`] on pure Wayland without XWayland. Native + /// [`HotkeyBackend::WaylandPortal`] support is deferred to DW-96. fn register_hotkey(&self, accelerator: &str) -> Result; - /// Enable auto-start on login. Story 8.4 / FR41–FR43. - fn autostart_enable(&self) -> Result<(), NoteyError>; + /// Enable auto-start on login (Story 8.4 / FR41–FR43, DW-97). + /// + /// Delegates to `tauri-plugin-autostart` via the Tauri [`AppHandle`], which + /// owns the per-OS launch-agent mechanism (plist / `.desktop` / registry). + /// + /// [`AppHandle`]: tauri::AppHandle + fn autostart_enable(&self, app: &tauri::AppHandle) -> Result<(), NoteyError>; - /// Disable auto-start on login. - fn autostart_disable(&self) -> Result<(), NoteyError>; + /// Disable auto-start on login (DW-97). See [`autostart_enable`]. + /// + /// [`autostart_enable`]: Platform::autostart_enable + fn autostart_disable(&self, app: &tauri::AppHandle) -> Result<(), NoteyError>; - /// Whether auto-start on login is currently configured. - fn autostart_is_enabled(&self) -> Result; + /// Whether auto-start on login is currently registered at the OS level + /// (DW-97). Reports the live plugin state. + fn autostart_is_enabled(&self, app: &tauri::AppHandle) -> Result; /// Whether the OS has granted the accessibility permission required for the /// global hotkey. Non-macOS platforms return `Ok(true)` (no such gate). @@ -97,3 +114,124 @@ pub fn current() -> Box { Box::new(windows::WindowsPlatform::new()) } } + +// ── Shared auto-start delegation (Story 8.4 / FR41–FR43 / DW-97) ───────────── +// +// Auto-start is platform-agnostic at this layer: `tauri-plugin-autostart` owns +// the per-OS launch-agent mechanism (plist / `.desktop` / registry), so the +// three per-OS `Platform::autostart_*` impls all delegate here. Centralizing the +// `app.autolaunch()` calls in one place keeps the impls thin and removes the +// cross-platform-divergence risk of reimplementing the plugin per OS. + +/// Register the OS launch agent so Notey starts on login. +pub(crate) fn autostart_enable(app: &tauri::AppHandle) -> Result<(), NoteyError> { + use tauri_plugin_autostart::ManagerExt; + app.autolaunch() + .enable() + .map_err(|e| NoteyError::Config(format!("Failed to enable auto-start: {e}"))) +} + +/// Remove the OS launch agent so Notey no longer starts on login. +pub(crate) fn autostart_disable(app: &tauri::AppHandle) -> Result<(), NoteyError> { + use tauri_plugin_autostart::ManagerExt; + app.autolaunch() + .disable() + .map_err(|e| NoteyError::Config(format!("Failed to disable auto-start: {e}"))) +} + +/// Report whether the OS launch agent is currently registered. +pub(crate) fn autostart_is_enabled(app: &tauri::AppHandle) -> Result { + use tauri_plugin_autostart::ManagerExt; + app.autolaunch() + .is_enabled() + .map_err(|e| NoteyError::Config(format!("Failed to query auto-start state: {e}"))) +} + +// ── Shared path resolvers (Story 8.5 / FR51 / FR58) ────────────────────────── +// +// The per-OS `data_dir`/`socket_path` impls delegate here so resolution lives in +// exactly one place. `namespace` differs per OS (`notey` vs `com.notey.app`) to +// match `services::config::config_dir`'s existing convention. + +/// Resolve the per-user data directory, namespaced for this OS. +/// +/// Honors the `NOTEY_DATA_DIR` env override first (the hermetic-test seam, +/// mirroring `NOTEY_SOCKET_PATH`); otherwise `dirs::data_dir()` joined with +/// `namespace` (`$XDG_DATA_HOME` / `%APPDATA%` / `~/Library/Application Support`). +/// Pure resolver — the caller creates the directory. Returns +/// [`NoteyError::Config`] when no platform data directory can be determined. +pub(crate) fn resolve_data_dir(namespace: &str) -> Result { + if let Ok(custom) = std::env::var("NOTEY_DATA_DIR") { + return Ok(PathBuf::from(custom)); + } + dirs::data_dir() + .map(|base| base.join(namespace)) + .ok_or_else(|| { + NoteyError::Config("Could not determine platform data directory".to_string()) + }) +} + +/// Resolve the per-user config directory, namespaced for this OS (Story 8.6). +/// +/// `dirs::config_dir()` joined with `namespace` (`$XDG_CONFIG_HOME` / `%APPDATA%` +/// / `~/Library/Application Support`). Pure resolver — the caller creates the +/// directory. This is the single implementation behind both the [`Platform`] +/// trait's `config_dir` and `services::config::config_dir`. Returns +/// [`NoteyError::Config`] when no platform config directory can be determined. +pub(crate) fn resolve_config_dir(namespace: &str) -> Result { + dirs::config_dir() + .map(|base| base.join(namespace)) + .ok_or_else(|| { + NoteyError::Config("Could not determine platform config directory".to_string()) + }) +} + +/// Default per-user Unix socket path (no override seams — those live in +/// `socket_server::socket_path`). Prefers `$XDG_RUNTIME_DIR/notey.sock` (a dir +/// that is itself `0700`), falling back to a user-scoped temp-dir path. +#[cfg(unix)] +pub(crate) fn resolve_unix_socket() -> PathBuf { + if let Some(dir) = dirs::runtime_dir() { + return dir.join("notey.sock"); + } + let file_name = user_scope_token() + .map(|token| format!("notey-{token}.sock")) + .unwrap_or_else(|| "notey.sock".to_string()); + std::env::temp_dir().join(file_name) +} + +/// Default per-user Windows named-pipe name (no override seams). +#[cfg(windows)] +pub(crate) fn resolve_windows_socket() -> PathBuf { + PathBuf::from( + user_scope_token() + .map(|token| format!("notey-{token}")) + .unwrap_or_else(|| "notey".to_string()), + ) +} + +/// Derive a stable, filesystem-safe per-user token for fallback socket naming. +#[cfg(any(unix, windows))] +fn user_scope_token() -> Option { + dirs::home_dir() + .as_deref() + .and_then(Path::file_name) + .and_then(|name| name.to_str()) + .map(str::to_owned) + .or_else(|| std::env::var("USER").ok()) + .or_else(|| std::env::var("USERNAME").ok()) + .and_then(|candidate| { + let sanitized: String = candidate + .chars() + .map(|c| { + if c.is_ascii_alphanumeric() { + c.to_ascii_lowercase() + } else { + '-' + } + }) + .collect(); + let trimmed = sanitized.trim_matches('-'); + (!trimmed.is_empty()).then(|| trimmed.to_string()) + }) +} diff --git a/src-tauri/src/platform/windows.rs b/src-tauri/src/platform/windows.rs index 58adace..9ce37b9 100644 --- a/src-tauri/src/platform/windows.rs +++ b/src-tauri/src/platform/windows.rs @@ -1,4 +1,6 @@ -//! Windows [`Platform`] implementation. RED-PHASE STUB (Story 8.6). +//! Windows [`Platform`] implementation. Paths + hotkey-backend selection +//! (Stories 8.5/8.6) and `autostart_*` (DW-97 — delegated to +//! `tauri-plugin-autostart`'s Run-key entry) are implemented. use std::path::PathBuf; @@ -21,35 +23,47 @@ impl Platform for WindowsPlatform { } fn data_dir(&self) -> Result { - todo!("Story 8.5: %APPDATA%\\notey (per-user)") + // %APPDATA%\notey, per-user (Story 8.5). + super::resolve_data_dir("notey") } fn config_dir(&self) -> Result { - todo!("Story 8.6: %APPDATA%\\notey") + // %APPDATA%\notey, per-user (Story 8.6). + super::resolve_config_dir("notey") } fn log_dir(&self) -> Result { - todo!("Story 8.6: %LOCALAPPDATA%\\notey\\logs") + // %LOCALAPPDATA%\notey\logs, per-user (Story 8.6). + dirs::data_local_dir() + .map(|base| base.join("notey").join("logs")) + .ok_or_else(|| { + NoteyError::Config("Could not determine local data directory for logs".to_string()) + }) } fn socket_path(&self) -> PathBuf { - todo!("Story 8.5: user-scoped named pipe") + // User-scoped namespaced pipe `notey-` (Story 8.5). + super::resolve_windows_socket() } - fn register_hotkey(&self, accelerator: &str) -> Result { - todo!("Story 8.6: standard plugin registration for {accelerator}") + fn register_hotkey(&self, _accelerator: &str) -> Result { + // Story 8.6: Windows has a single global-shortcut backend (the standard + // plugin). The actual registration happens in `lib.rs`; this only reports + // the backend. + Ok(HotkeyBackend::Standard) } - fn autostart_enable(&self) -> Result<(), NoteyError> { - todo!("Story 8.4: add HKCU Run-key entry") + fn autostart_enable(&self, app: &tauri::AppHandle) -> Result<(), NoteyError> { + // DW-97: delegate to the shared tauri-plugin-autostart helper (Story 8.4). + super::autostart_enable(app) } - fn autostart_disable(&self) -> Result<(), NoteyError> { - todo!("Story 8.4: remove HKCU Run-key entry") + fn autostart_disable(&self, app: &tauri::AppHandle) -> Result<(), NoteyError> { + super::autostart_disable(app) } - fn autostart_is_enabled(&self) -> Result { - todo!("Story 8.4: check the HKCU Run-key entry") + fn autostart_is_enabled(&self, app: &tauri::AppHandle) -> Result { + super::autostart_is_enabled(app) } fn accessibility_permission_granted(&self) -> Result { diff --git a/src-tauri/src/services/autostart.rs b/src-tauri/src/services/autostart.rs deleted file mode 100644 index 039aaa7..0000000 --- a/src-tauri/src/services/autostart.rs +++ /dev/null @@ -1,60 +0,0 @@ -//! Auto-start-on-login service: enable/disable the platform launch agent and -//! persist the user's preference. -//! -//! **RED-PHASE STUB (Epic 8 — Story 8.4).** Unimplemented scaffold. Acceptance -//! tests live in `tests/autostart_tests.rs`, marked `#[ignore = "red-phase: -//! Story 8.4"]`. -//! -//! ## Green-phase wiring (do this when implementing) -//! - Add `tauri-plugin-autostart` (verify the current 2.x version on crates.io — -//! do not pin from memory) initialized with `MacosLauncher::LaunchAgent`. -//! - Delegate `enable`/`disable`/`is_enabled` to the plugin via the [`Platform`] -//! abstraction (see [`crate::platform`]). -//! - Persist the preference as `[autostart] enabled = `. NOTE: AC 8.4 names -//! the key `[general] auto_start`; this scaffold keeps a dedicated section to -//! avoid a ~50-site TypeScript ripple from changing `GeneralConfig` during the -//! red phase. Reconcile the section name at green phase. -//! - Add the capability ACL entries `autostart:allow-enable`, -//! `autostart:allow-disable`, `autostart:allow-is-enabled`. - -use std::path::{Path, PathBuf}; - -use serde::{Deserialize, Serialize}; -use specta::Type; - -use crate::errors::NoteyError; - -/// Persisted auto-start preference (`autostart.toml`). -#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize, Type)] -#[serde(rename_all = "camelCase")] -pub struct AutostartState { - #[serde(default)] - pub enabled: bool, -} - -/// Full path to `autostart.toml` within the given config directory. -pub fn state_file_path(config_dir: &Path) -> PathBuf { - config_dir.join("autostart.toml") -} - -/// Load the persisted preference, defaulting to disabled when missing. -pub fn load(config_dir: &Path) -> Result { - todo!("Story 8.4: read autostart.toml under {config_dir:?}, default to disabled") -} - -/// Enable auto-start: register the platform launch agent AND persist -/// `enabled = true`. Idempotent. -pub fn enable(config_dir: &Path) -> Result<(), NoteyError> { - todo!("Story 8.4: register platform autostart + persist enabled=true under {config_dir:?}") -} - -/// Disable auto-start: remove the platform launch agent AND persist -/// `enabled = false`. Idempotent. -pub fn disable(config_dir: &Path) -> Result<(), NoteyError> { - todo!("Story 8.4: remove platform autostart + persist enabled=false under {config_dir:?}") -} - -/// Whether auto-start is currently enabled at the platform level. -pub fn is_enabled() -> Result { - todo!("Story 8.4: query the platform autostart mechanism") -} diff --git a/src-tauri/src/services/config.rs b/src-tauri/src/services/config.rs index a0574c3..a00c96c 100644 --- a/src-tauri/src/services/config.rs +++ b/src-tauri/src/services/config.rs @@ -7,17 +7,12 @@ use crate::models::config::{AppConfig, Theme}; /// Returns the platform-standard config directory for Notey. /// Linux: `$XDG_CONFIG_HOME/notey/`, macOS: `~/Library/Application Support/com.notey.app/`, /// Windows: `%APPDATA%\notey\` +/// +/// Delegates to [`crate::platform::current`]'s `config_dir` so config-path +/// resolution has a single source of truth in the `Platform` abstraction +/// (Story 8.6 / FR58). The returned path is identical to the prior inline logic. pub fn config_dir() -> Result { - let base = dirs::config_dir().ok_or_else(|| { - NoteyError::Config("Could not determine platform config directory".to_string()) - })?; - - #[cfg(target_os = "macos")] - let dir = base.join("com.notey.app"); - #[cfg(not(target_os = "macos"))] - let dir = base.join("notey"); - - Ok(dir) + crate::platform::current().config_dir() } /// Returns the full path to config.toml within the config directory. diff --git a/src-tauri/src/services/mod.rs b/src-tauri/src/services/mod.rs index 74e0e86..69ec2ad 100644 --- a/src-tauri/src/services/mod.rs +++ b/src-tauri/src/services/mod.rs @@ -1,4 +1,3 @@ -pub mod autostart; pub mod config; pub mod export; pub mod notes; diff --git a/src-tauri/src/services/notes.rs b/src-tauri/src/services/notes.rs index f81d152..11b411a 100644 --- a/src-tauri/src/services/notes.rs +++ b/src-tauri/src/services/notes.rs @@ -1210,7 +1210,12 @@ mod tests { /// Create a titled note in `workspace_id` and stamp a fixed `updated_at` so /// ordering is deterministic. - fn seed_note(conn: &Connection, title: &str, workspace_id: Option, updated_at: &str) -> i64 { + fn seed_note( + conn: &Connection, + title: &str, + workspace_id: Option, + updated_at: &str, + ) -> i64 { let note = create_note(conn, "markdown", workspace_id).expect("create note"); conn.execute( "UPDATE notes SET title = ?1, updated_at = ?2 WHERE id = ?3", @@ -1259,7 +1264,11 @@ mod tests { seed_note(&conn, "from-two", Some(ws2), "2026-06-12T00:00:00+00:00"); let items = list_notes_with_workspace(&conn, Some("dup")).expect("list"); - assert_eq!(items.len(), 2, "name filter must match both 'dup' workspaces"); + assert_eq!( + items.len(), + 2, + "name filter must match both 'dup' workspaces" + ); } #[test] diff --git a/src-tauri/src/services/onboarding.rs b/src-tauri/src/services/onboarding.rs index ed14948..b57dc31 100644 --- a/src-tauri/src/services/onboarding.rs +++ b/src-tauri/src/services/onboarding.rs @@ -1,20 +1,17 @@ //! First-run onboarding state: persistence of the "onboarding complete" flag and //! the early-session counter that drives progressive command-palette hints. //! -//! **RED-PHASE STUB (Epic 8 — Stories 8.1 & 8.3).** Every function below is an -//! unimplemented scaffold (`todo!`). The acceptance tests in -//! `tests/onboarding_tests.rs` are written against this contract but marked -//! `#[ignore = "red-phase: Story 8.x"]` so the suite stays green until a developer -//! implements a function and activates its tests (TDD red → green). +//! State is serialized to `onboarding.toml` in the platform config dir (sibling +//! to `config.toml`; see [`crate::services::config::config_dir`]) using the same +//! atomic temp-file + rename write the config service uses. A missing or corrupt +//! file resolves to the default state — onboarding never fails the app. //! -//! ## Green-phase wiring (do this when implementing) -//! - Persist `OnboardingState` to `onboarding.toml` in the platform config dir -//! (sibling to `config.toml`; see [`crate::services::config::config_dir`]). -//! - Expose `get_onboarding_state` / `complete_onboarding` Tauri commands, register -//! them in `lib.rs::specta_builder`, add their permission TOMLs + capabilities, -//! and extend `EXPECTED_COMMANDS` in `tests/acl_tests.rs`. +//! The `get_onboarding_state` / `complete_onboarding` / `increment_onboarding_session` +//! Tauri commands (in `commands::onboarding`) expose this service to the frontend. +use std::fs; use std::path::{Path, PathBuf}; +use std::sync::Mutex; use serde::{Deserialize, Serialize}; use specta::Type; @@ -25,6 +22,8 @@ use crate::errors::NoteyError; /// is shown before it disappears permanently (Story 8.1 progressive disclosure). pub const COMMAND_HINT_SESSION_LIMIT: u32 = 5; +static ONBOARDING_WRITE_LOCK: Mutex<()> = Mutex::new(()); + /// Persisted first-run onboarding state. /// /// Serialized to `onboarding.toml`. `complete` gates the one-time onboarding @@ -43,37 +42,114 @@ pub struct OnboardingState { pub sessions_seen: u32, } +#[derive(Debug, Default, Serialize, Deserialize)] +struct PersistedOnboardingState { + #[serde(default)] + complete: bool, + #[serde(default, alias = "sessionsSeen")] + sessions_seen: u32, +} + +impl From for OnboardingState { + fn from(state: PersistedOnboardingState) -> Self { + Self { + complete: state.complete, + sessions_seen: state.sessions_seen, + } + } +} + +impl From<&OnboardingState> for PersistedOnboardingState { + fn from(state: &OnboardingState) -> Self { + Self { + complete: state.complete, + sessions_seen: state.sessions_seen, + } + } +} + /// Full path to `onboarding.toml` within the given config directory. pub fn state_file_path(config_dir: &Path) -> PathBuf { config_dir.join("onboarding.toml") } /// Load onboarding state from disk, returning the default (not-complete, zero -/// sessions) when the file is missing or unreadable. +/// sessions) when the file is missing or corrupt — onboarding state must never +/// fail the app. pub fn load(config_dir: &Path) -> Result { - todo!("Story 8.1: read onboarding.toml under {config_dir:?}, default on missing/corrupt") + let path = state_file_path(config_dir); + if !path.exists() { + return Ok(OnboardingState::default()); + } + match fs::read_to_string(&path) { + Ok(contents) => Ok( + toml::from_str::(&contents).map_or_else( + |e| { + eprintln!( + "Warning: onboarding.toml is corrupt ({e}), falling back to defaults" + ); + OnboardingState::default() + }, + OnboardingState::from, + ), + ), + Err(e) => { + eprintln!("Warning: failed to read onboarding.toml ({e}), falling back to defaults"); + Ok(OnboardingState::default()) + } + } } /// Returns whether onboarding has been completed. pub fn is_complete(config_dir: &Path) -> Result { - todo!("Story 8.1: return load(config_dir)?.complete for {config_dir:?}") + Ok(load(config_dir)?.complete) } -/// Mark onboarding as complete and persist atomically. Idempotent. +/// Mark onboarding as complete and persist atomically. Idempotent — preserves the +/// existing session counter. pub fn mark_complete(config_dir: &Path) -> Result<(), NoteyError> { - todo!("Story 8.1: set complete=true and atomically write onboarding.toml under {config_dir:?}") + let _guard = ONBOARDING_WRITE_LOCK + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()); + let mut state = load(config_dir)?; + state.complete = true; + save(config_dir, &state) } /// Increment the session counter, persist, and return the new count. pub fn increment_session(config_dir: &Path) -> Result { - todo!("Story 8.1: load, bump sessions_seen, persist, return new count for {config_dir:?}") + let _guard = ONBOARDING_WRITE_LOCK + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()); + let mut state = load(config_dir)?; + state.sessions_seen = state.sessions_seen.saturating_add(1); + save(config_dir, &state)?; + Ok(state.sessions_seen) } /// Whether the early "Ctrl+P for commands" status-bar hint should still be shown /// for the given state (i.e. within the first [`COMMAND_HINT_SESSION_LIMIT`] -/// sessions and onboarding done). +/// sessions). pub fn should_show_command_hint(state: &OnboardingState) -> bool { - todo!( - "Story 8.1: true when sessions_seen < COMMAND_HINT_SESSION_LIMIT (state: {state:?})" - ) + state.sessions_seen < COMMAND_HINT_SESSION_LIMIT +} + +/// Writes onboarding state to `onboarding.toml` using an atomic temp-file + rename, +/// mirroring [`crate::services::config::save`]. Cleans up the temp file on failure. +fn save(config_dir: &Path, state: &OnboardingState) -> Result<(), NoteyError> { + fs::create_dir_all(config_dir)?; + let path = state_file_path(config_dir); + let tmp_path = config_dir.join("onboarding.toml.tmp"); + let persisted = PersistedOnboardingState::from(state); + let contents = toml::to_string_pretty(&persisted) + .map_err(|e| NoteyError::Config(format!("Failed to serialize onboarding state: {e}")))?; + if let Err(e) = fs::write(&tmp_path, &contents) { + let _ = fs::remove_file(&tmp_path); + return Err(e.into()); + } + if let Err(e) = fs::rename(&tmp_path, &path) { + let _ = fs::remove_file(&tmp_path); + return Err(e.into()); + } + Ok(()) } diff --git a/src-tauri/src/services/search_service.rs b/src-tauri/src/services/search_service.rs index 09b9d19..f399f1a 100644 --- a/src-tauri/src/services/search_service.rs +++ b/src-tauri/src/services/search_service.rs @@ -429,8 +429,8 @@ mod tests { ); let existing = search_notes(&conn, "by_name_term_xyz", None).expect("search"); - let by_name = search_notes_by_workspace_name(&conn, "by_name_term_xyz", None) - .expect("search"); + let by_name = + search_notes_by_workspace_name(&conn, "by_name_term_xyz", None).expect("search"); assert_eq!( serde_json::to_value(&by_name).expect("serialize by-name search"), serde_json::to_value(&existing).expect("serialize existing search"), @@ -477,7 +477,11 @@ mod tests { let results = search_notes_by_workspace_name(&conn, "dup_term_qrs", Some("dup")).expect("search"); - assert_eq!(results.len(), 2, "duplicate names match every sharing workspace"); + assert_eq!( + results.len(), + 2, + "duplicate names match every sharing workspace" + ); } #[test] diff --git a/src-tauri/src/services/window_layout.rs b/src-tauri/src/services/window_layout.rs index 3ebb076..5b9228c 100644 --- a/src-tauri/src/services/window_layout.rs +++ b/src-tauri/src/services/window_layout.rs @@ -74,7 +74,11 @@ pub fn compute_layout( work_area: Option, scale_factor: f64, ) -> Result { - let scale = if scale_factor > 0.0 { scale_factor } else { 1.0 }; + let scale = if scale_factor > 0.0 { + scale_factor + } else { + 1.0 + }; match mode { "floating" => Ok(LayoutPlan { @@ -125,7 +129,9 @@ pub fn compute_layout( skip_taskbar: false, maximize: true, }), - other => Err(NoteyError::Validation(format!("Unknown layout mode: {other}"))), + other => Err(NoteyError::Validation(format!( + "Unknown layout mode: {other}" + ))), } } diff --git a/src-tauri/tauri.conf.json b/src-tauri/tauri.conf.json index 60a17d1..240aaaa 100644 --- a/src-tauri/tauri.conf.json +++ b/src-tauri/tauri.conf.json @@ -1,8 +1,8 @@ { "$schema": "https://schema.tauri.app/config/2", - "productName": "tauri-app", + "productName": "Notey", "version": "0.1.0", - "identifier": "com.pinkyd.tauri-app", + "identifier": "com.pinkyd.notey", "build": { "beforeDevCommand": "npm run dev", "devUrl": "http://localhost:1420", diff --git a/src-tauri/tests/acl_tests.rs b/src-tauri/tests/acl_tests.rs index 1ac72a6..29f81dc 100644 --- a/src-tauri/tests/acl_tests.rs +++ b/src-tauri/tests/acl_tests.rs @@ -14,6 +14,13 @@ const EXPECTED_COMMANDS: &[&str] = &[ "allow-list-notes", "allow-get-config", "allow-update-config", + "allow-get-onboarding-state", + "allow-complete-onboarding", + "allow-increment-onboarding-session", + "allow-check-accessibility-permission", + "allow-open-accessibility-settings", + "allow-set-autostart", + "allow-get-autostart", "allow-dismiss-window", "allow-apply-layout-mode", "allow-create-workspace", @@ -27,6 +34,7 @@ const EXPECTED_COMMANDS: &[&str] = &[ "allow-search-notes", "allow-export-markdown", "allow-export-json", + "allow-get-hotkey-status", ]; // P0-INT-006: Tauri ACL rejects unauthorized commands diff --git a/src-tauri/tests/autostart_tests.rs b/src-tauri/tests/autostart_tests.rs index 8468d45..ad18943 100644 --- a/src-tauri/tests/autostart_tests.rs +++ b/src-tauri/tests/autostart_tests.rs @@ -1,69 +1,78 @@ -//! ATDD red-phase acceptance tests — Story 8.4 (Auto-Start on Login), -//! preference-persistence + service-contract slice. +//! Acceptance tests — Story 8.4 (Auto-Start on Login), preference-persistence +//! slice. //! -//! Every test is `#[ignore = "red-phase: Story 8.4"]` against the unimplemented -//! [`tauri_app_lib::services::autostart`] scaffold. Platform-level launch-agent -//! behavior (does the OS actually start the app at login?) is verified by -//! manual/platform QA — these tests pin the persistence and idempotence contract. +//! The user's auto-start preference is the single source of truth at `config.toml` +//! `[general] auto_start` (serde key `autoStart`). These tests pin the persistence +//! and idempotence contract through the config service, hermetically against a +//! `TempDir`. Platform-level launch-agent behavior (does the OS actually start the +//! app at login?) is owned by `tauri-plugin-autostart` and verified by +//! manual/platform QA — it is not exercised here. //! -//! cargo test --test autostart_tests -- --ignored +//! cargo test --test autostart_tests use tempfile::TempDir; -use tauri_app_lib::services::autostart::{self, AutostartState}; +use notey_lib::models::config::AppConfig; +use notey_lib::services::config; + +/// Persist a preference exactly as the `set_autostart` command does: set the field +/// on the loaded config and save through the config service. +fn persist(config_dir: &std::path::Path, enabled: bool) { + let mut cfg = config::load_or_create(config_dir).expect("load config"); + cfg.general.auto_start = enabled; + config::save(config_dir, &cfg).expect("save config"); +} + +fn load_enabled(config_dir: &std::path::Path) -> bool { + config::load_or_create(config_dir) + .expect("load config") + .general + .auto_start +} /// AC: a fresh install has auto-start disabled. #[test] -#[ignore = "red-phase: Story 8.4"] -fn load_defaults_to_disabled() { +fn fresh_install_defaults_to_disabled() { let tmp = TempDir::new().unwrap(); - let state = autostart::load(tmp.path()).expect("load must succeed on a fresh dir"); - assert_eq!(state, AutostartState { enabled: false }); + assert!(!load_enabled(tmp.path())); + assert!(!AppConfig::default().general.auto_start); } -/// AC: "the user enables auto-start … the setting is saved to config: -/// `auto_start = true`". (Scaffold persists `[autostart] enabled` — see module -/// docs; reconcile the section name at green phase.) +/// AC: enabling auto-start saves `[general] auto_start = true` to config.toml. #[test] -#[ignore = "red-phase: Story 8.4"] fn enable_persists_true() { let tmp = TempDir::new().unwrap(); - autostart::enable(tmp.path()).expect("enable must persist"); - assert!( - autostart::load(tmp.path()).unwrap().enabled, - "enabled preference must survive a reload" - ); - assert!(autostart::state_file_path(tmp.path()).exists()); + persist(tmp.path(), true); + assert!(load_enabled(tmp.path()), "preference must survive a reload"); + assert!(tmp.path().join("config.toml").exists()); } -/// AC: "the user disables auto-start … the config is updated: `auto_start = false`". +/// AC: disabling auto-start updates the config to `auto_start = false`. #[test] -#[ignore = "red-phase: Story 8.4"] fn disable_persists_false() { let tmp = TempDir::new().unwrap(); - autostart::enable(tmp.path()).unwrap(); - autostart::disable(tmp.path()).expect("disable must persist"); - assert!(!autostart::load(tmp.path()).unwrap().enabled); + persist(tmp.path(), true); + persist(tmp.path(), false); + assert!(!load_enabled(tmp.path())); } -/// Enabling twice is a no-op at the persistence layer (no duplicate launch agent). +/// Enabling twice is a no-op at the persistence layer (no divergent state). #[test] -#[ignore = "red-phase: Story 8.4"] fn enable_is_idempotent() { let tmp = TempDir::new().unwrap(); - autostart::enable(tmp.path()).unwrap(); - autostart::enable(tmp.path()).unwrap(); - assert!(autostart::load(tmp.path()).unwrap().enabled); + persist(tmp.path(), true); + persist(tmp.path(), true); + assert!(load_enabled(tmp.path())); } -/// AC: the platform mechanism is the source of truth for the *active* state. -/// `is_enabled` reflects what the OS reports (here: disabled by default in a -/// clean test environment). +/// A config file predating Story 8.4 (no `autoStart` key) loads as disabled. #[test] -#[ignore = "red-phase: Story 8.4"] -fn is_enabled_reports_platform_state() { - assert!( - !autostart::is_enabled().expect("is_enabled must query the platform"), - "a clean test environment must report auto-start as not registered" - ); +fn missing_key_loads_as_disabled() { + let tmp = TempDir::new().unwrap(); + std::fs::write( + tmp.path().join("config.toml"), + "[general]\ntheme = \"dark\"\nlayoutMode = \"floating\"\n", + ) + .unwrap(); + assert!(!load_enabled(tmp.path())); } diff --git a/src-tauri/tests/db_tests.rs b/src-tauri/tests/db_tests.rs index c7e33db..f8a484b 100644 --- a/src-tauri/tests/db_tests.rs +++ b/src-tauri/tests/db_tests.rs @@ -3,8 +3,8 @@ mod helpers; use rusqlite::params; use helpers::factories::{create_temp_db, NoteBuilder}; -use tauri_app_lib::errors::NoteyError; -use tauri_app_lib::services::notes; +use notey_lib::errors::NoteyError; +use notey_lib::services::notes; #[test] fn test_notes_table_creation() { @@ -163,7 +163,7 @@ fn test_db_write_survives_reopen() { drop(conn); // Reopen the same database - let conn2 = tauri_app_lib::db::init_db(dir.path().to_path_buf()).expect("reopen failed"); + let conn2 = notey_lib::db::init_db(dir.path().to_path_buf()).expect("reopen failed"); let reloaded = notes::get_note(&conn2, note_id).expect("get_note after reopen failed"); assert_eq!(reloaded.title, "durable title"); @@ -220,7 +220,7 @@ fn test_migration_idempotent_on_existing_db() { drop(conn); // Re-init the same DB (migrations should be a no-op) - let conn2 = tauri_app_lib::db::init_db(dir.path().to_path_buf()).expect("re-init failed"); + let conn2 = notey_lib::db::init_db(dir.path().to_path_buf()).expect("re-init failed"); let schema2: String = conn2 .query_row( "SELECT sql FROM sqlite_master WHERE type='table' AND name='notes'", diff --git a/src-tauri/tests/helpers/factories.rs b/src-tauri/tests/helpers/factories.rs index d1893f9..37ea69b 100644 --- a/src-tauri/tests/helpers/factories.rs +++ b/src-tauri/tests/helpers/factories.rs @@ -2,8 +2,8 @@ use chrono::Utc; use rusqlite::{params, Connection}; use tempfile::TempDir; -use tauri_app_lib::db; -use tauri_app_lib::models::Note; +use notey_lib::db; +use notey_lib::models::Note; /// Create a file-backed temp DB with full init (PRAGMAs + migrations). /// Returns the connection and a `TempDir` guard — the directory is automatically diff --git a/src-tauri/tests/ipc_tests.rs b/src-tauri/tests/ipc_tests.rs index 385c3f0..aeeed2b 100644 --- a/src-tauri/tests/ipc_tests.rs +++ b/src-tauri/tests/ipc_tests.rs @@ -18,8 +18,8 @@ use tempfile::TempDir; use helpers::factories::create_temp_db; use interprocess::local_socket::Stream; -use tauri_app_lib::ipc::protocol::{IpcResponse, MAX_CONTENT_BYTES}; -use tauri_app_lib::ipc::socket_server::{self, Handler, IpcServer}; +use notey_lib::ipc::protocol::{IpcResponse, MAX_CONTENT_BYTES}; +use notey_lib::ipc::socket_server::{self, Handler, IpcServer}; /// A running server bound to a temp socket over a shared temp DB. The server is /// held only to keep it alive and to unlink its socket on drop. @@ -35,6 +35,35 @@ struct TestServer { static SOCKET_SEQ: AtomicUsize = AtomicUsize::new(0); static SOCKET_PATH_ENV_LOCK: LazyLock> = LazyLock::new(|| Mutex::new(())); +/// Restores a process env var to its prior value, including non-Unicode values. +struct EnvVarGuard { + key: &'static str, + prior: Option, +} + +impl EnvVarGuard { + fn set(key: &'static str, value: &str) -> Self { + let prior = std::env::var_os(key); + std::env::set_var(key, value); + Self { key, prior } + } + + fn unset(key: &'static str) -> Self { + let prior = std::env::var_os(key); + std::env::remove_var(key); + Self { key, prior } + } +} + +impl Drop for EnvVarGuard { + fn drop(&mut self) { + match &self.prior { + Some(value) => std::env::set_var(self.key, value), + None => std::env::remove_var(self.key), + } + } +} + /// Serializes EVERY `IpcServer::start` in this suite. `IpcServer::start` reads the /// process-global `NOTEY_IPC_*` env vars on every start, so an env-setting test's /// "set env → start → clear env" window must not overlap any other server start — @@ -64,7 +93,7 @@ impl TestServer { let handler_conn = Arc::clone(&conn); let handler: Handler = Arc::new(move |raw: &[u8]| { let guard = handler_conn.lock().unwrap_or_else(|e| e.into_inner()); - tauri_app_lib::ipc::protocol::handle_request(&guard, raw) + notey_lib::ipc::protocol::handle_request(&guard, raw) }); // Held across env mutation AND `IpcServer::start` (which reads the env), @@ -208,18 +237,20 @@ fn int_002_008_socket_path_is_user_scoped() { .unwrap_or_else(|poisoned| poisoned.into_inner()); // Override seam works (the testability ASR). - std::env::set_var("NOTEY_SOCKET_PATH", "/tmp/notey-override.sock"); - assert_eq!( - socket_server::socket_path(), - PathBuf::from("/tmp/notey-override.sock") - ); - std::env::remove_var("NOTEY_SOCKET_PATH"); + { + let _env = EnvVarGuard::set("NOTEY_SOCKET_PATH", "/tmp/notey-override.sock"); + assert_eq!( + socket_server::socket_path(), + PathBuf::from("/tmp/notey-override.sock") + ); + } // Default resolves under the per-user runtime dir (itself 0700) on Linux, // which — together with the 0600 file mode — is the automatable slice of // cross-user isolation. True multi-uid access is manual QA (RISK-E6-007). #[cfg(target_os = "linux")] if let Some(runtime) = dirs::runtime_dir() { + let _env = EnvVarGuard::unset("NOTEY_SOCKET_PATH"); let resolved = socket_server::socket_path(); assert!( resolved.starts_with(&runtime), @@ -229,6 +260,23 @@ fn int_002_008_socket_path_is_user_scoped() { } } +// ── 8.5: socket_server default delegates to the Platform abstraction ────────── + +#[test] +fn socket_server_default_matches_platform() { + let _guard = SOCKET_PATH_ENV_LOCK + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()); + let _env = EnvVarGuard::unset("NOTEY_SOCKET_PATH"); + + // With no override seam set, socket_server must defer to the single source of + // truth in the platform abstraction (Story 8.5). + let from_server = socket_server::socket_path(); + let from_platform = notey_lib::platform::current().socket_path(); + + assert_eq!(from_server, from_platform); +} + // ── 6.2-INT-003: protocol robustness — malformed / unknown, no panic ────────── #[test] @@ -347,7 +395,7 @@ fn start_at(path: &Path, conn: Arc>) -> IpcServer { fn handler_for_conn(conn: Arc>) -> Handler { Arc::new(move |raw: &[u8]| { let guard = conn.lock().unwrap_or_else(|e| e.into_inner()); - tauri_app_lib::ipc::protocol::handle_request(&guard, raw) + notey_lib::ipc::protocol::handle_request(&guard, raw) }) } diff --git a/src-tauri/tests/onboarding_tests.rs b/src-tauri/tests/onboarding_tests.rs index dca4cc5..b1e8490 100644 --- a/src-tauri/tests/onboarding_tests.rs +++ b/src-tauri/tests/onboarding_tests.rs @@ -1,24 +1,16 @@ //! ATDD red-phase acceptance tests — Story 8.1 (First-Run Detection & Onboarding //! Overlay), backend persistence slice. //! -//! Every test is `#[ignore = "red-phase: Story 8.1"]`: the assertions encode the -//! *expected* behavior of [`tauri_app_lib::services::onboarding`], whose functions -//! are unimplemented (`todo!`) scaffolds. The suite stays green until a developer -//! implements a function and removes the matching `#[ignore]` (TDD red → green). -//! -//! Activate one test at a time: -//! cargo test --test onboarding_tests -- --ignored +//! These tests lock the persisted onboarding contract now that the Story 8.1 +//! green phase is active. use tempfile::TempDir; -use tauri_app_lib::services::onboarding::{ - self, OnboardingState, COMMAND_HINT_SESSION_LIMIT, -}; +use notey_lib::services::onboarding::{self, OnboardingState, COMMAND_HINT_SESSION_LIMIT}; /// AC: "the application starts for the first time (no `onboarding_complete` flag)". /// A fresh config dir yields the default state — not complete, zero sessions. #[test] -#[ignore = "red-phase: Story 8.1"] fn load_returns_default_state_on_first_run() { let tmp = TempDir::new().unwrap(); let state = onboarding::load(tmp.path()).expect("load must succeed on a fresh dir"); @@ -35,7 +27,6 @@ fn load_returns_default_state_on_first_run() { /// `onboarding_complete = true` is set in config". After marking complete, /// `is_complete` reports true on a fresh read from disk. #[test] -#[ignore = "red-phase: Story 8.1"] fn mark_complete_persists_and_is_observed_on_reload() { let tmp = TempDir::new().unwrap(); assert!(!onboarding::is_complete(tmp.path()).unwrap()); @@ -56,7 +47,6 @@ fn mark_complete_persists_and_is_observed_on_reload() { /// AC: "the overlay is never shown again". mark_complete is idempotent — calling /// it twice keeps `complete = true` and does not reset the session counter. #[test] -#[ignore = "red-phase: Story 8.1"] fn mark_complete_is_idempotent() { let tmp = TempDir::new().unwrap(); onboarding::increment_session(tmp.path()).unwrap(); @@ -65,13 +55,19 @@ fn mark_complete_is_idempotent() { let state = onboarding::load(tmp.path()).unwrap(); assert!(state.complete); - assert_eq!(state.sessions_seen, 1, "idempotent completion must not reset sessions"); + assert_eq!( + state.sessions_seen, 1, + "idempotent completion must not reset sessions" + ); + + let contents = std::fs::read_to_string(onboarding::state_file_path(tmp.path())).unwrap(); + assert!(contents.contains("sessions_seen = 1")); + assert!(!contents.contains("sessionsSeen")); } /// AC: "the user is within their first 5 sessions". The session counter /// increments and persists across reloads. #[test] -#[ignore = "red-phase: Story 8.1"] fn increment_session_counts_and_persists() { let tmp = TempDir::new().unwrap(); assert_eq!(onboarding::increment_session(tmp.path()).unwrap(), 1); @@ -86,11 +82,19 @@ fn increment_session_counts_and_persists() { /// AC: "after 5 sessions, the hint disappears permanently". The hint shows for the /// first `COMMAND_HINT_SESSION_LIMIT` sessions, then never again. #[test] -#[ignore = "red-phase: Story 8.1"] fn command_hint_retires_after_session_limit() { - let within = OnboardingState { complete: true, sessions_seen: 0 }; - let last = OnboardingState { complete: true, sessions_seen: COMMAND_HINT_SESSION_LIMIT - 1 }; - let past = OnboardingState { complete: true, sessions_seen: COMMAND_HINT_SESSION_LIMIT }; + let within = OnboardingState { + complete: true, + sessions_seen: 0, + }; + let last = OnboardingState { + complete: true, + sessions_seen: COMMAND_HINT_SESSION_LIMIT - 1, + }; + let past = OnboardingState { + complete: true, + sessions_seen: COMMAND_HINT_SESSION_LIMIT, + }; assert!(onboarding::should_show_command_hint(&within)); assert!(onboarding::should_show_command_hint(&last)); diff --git a/src-tauri/tests/platform_tests.rs b/src-tauri/tests/platform_tests.rs index e36c5b8..8beec84 100644 --- a/src-tauri/tests/platform_tests.rs +++ b/src-tauri/tests/platform_tests.rs @@ -1,21 +1,57 @@ //! ATDD red-phase acceptance tests — Stories 8.6 (Cross-Platform Verification & //! Wayland Fallback), 8.5 (Per-User Data Isolation), and 8.2 (macOS Accessibility -//! Permission Guidance), exercised through the [`tauri_app_lib::platform`] +//! Permission Guidance), exercised through the [`notey_lib::platform`] //! abstraction. //! -//! Tests are `#[ignore = "red-phase: Story 8.x"]` against the unimplemented -//! per-OS scaffolds. Assertions are `#[cfg(target_os = ...)]`-gated so each only -//! compiles/runs on the platform it describes (the CI matrix covers all five -//! targets). True cross-user isolation and real Wayland behavior are verified by +//! Assertions are `#[cfg(target_os = ...)]`-gated so each only compiles/runs on +//! the platform it describes (the CI matrix covers all five targets). True +//! cross-user isolation and real Wayland portal behavior are verified by //! platform QA; these pin the automatable contract. //! //! cargo test --test platform_tests -- --ignored -use tauri_app_lib::platform; +use notey_lib::platform; + +/// Serializes the two tests that read/mutate the process-global `NOTEY_DATA_DIR` +/// env var, so the override test cannot leak into the standard-path test when the +/// harness runs them on parallel threads. +static DATA_DIR_ENV_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(()); + +/// Serializes tests that read/mutate process-global display env vars. +#[cfg(target_os = "linux")] +static HOTKEY_ENV_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(()); + +/// Restores a process env var to its prior value, including non-Unicode values. +struct EnvVarGuard { + key: &'static str, + prior: Option, +} + +impl EnvVarGuard { + fn set(key: &'static str, value: &str) -> Self { + let prior = std::env::var_os(key); + std::env::set_var(key, value); + Self { key, prior } + } + + fn unset(key: &'static str) -> Self { + let prior = std::env::var_os(key); + std::env::remove_var(key); + Self { key, prior } + } +} + +impl Drop for EnvVarGuard { + fn drop(&mut self) { + match &self.prior { + Some(value) => std::env::set_var(self.key, value), + None => std::env::remove_var(self.key), + } + } +} /// AC 8.6: `current()` resolves to the implementation for the target OS. #[test] -#[ignore = "red-phase: Story 8.6"] fn current_resolves_to_target_platform() { let expected = if cfg!(target_os = "linux") { "linux" @@ -29,32 +65,134 @@ fn current_resolves_to_target_platform() { /// AC 8.5/8.6/FR58: the data directory is a per-user, platform-standard path. #[test] -#[ignore = "red-phase: Story 8.5"] fn data_dir_is_user_scoped_and_standard() { + let _guard = DATA_DIR_ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner()); + let _env = EnvVarGuard::unset("NOTEY_DATA_DIR"); + let dir = platform::current() .data_dir() .expect("data_dir must resolve"); - let s = dir.to_string_lossy(); - assert!(s.contains("notey"), "data dir must be namespaced to notey: {s}"); + let namespace = if cfg!(target_os = "macos") { + "com.notey.app" + } else { + "notey" + }; + let expected = dirs::data_dir() + .expect("platform data dir must resolve") + .join(namespace); + assert_eq!( + dir, expected, + "data dir must be the platform data dir plus the Notey namespace" + ); - #[cfg(unix)] - { - let home = std::env::var("HOME").unwrap_or_default(); - assert!( - !home.is_empty() && s.starts_with(&home), - "data dir must live under the current user's HOME ({home}): {s}" - ); - } + // macOS namespaces under the bundle identifier, mirroring config_dir. + #[cfg(target_os = "macos")] + assert!( + dir.to_string_lossy().contains("com.notey.app"), + "macOS data dir must use the bundle id namespace: {}", + dir.display() + ); +} + +/// AC 8.5: the `NOTEY_DATA_DIR` override seam (hermetic-test seam, mirroring +/// `NOTEY_SOCKET_PATH`) takes precedence over the platform-standard path. +#[test] +fn data_dir_honors_override_seam() { + let _guard = DATA_DIR_ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner()); + let _env = EnvVarGuard::set("NOTEY_DATA_DIR", "/tmp/notey-data-override"); + + let resolved = platform::current() + .data_dir() + .expect("override data_dir must resolve"); + assert_eq!( + resolved, + std::path::PathBuf::from("/tmp/notey-data-override") + ); +} + +/// AC 8.6/FR58: the config directory is a per-user, platform-standard path using +/// the same namespace convention as `services::config`. +#[test] +fn config_dir_is_user_scoped_and_standard() { + let dir = platform::current() + .config_dir() + .expect("config_dir must resolve"); + let namespace = if cfg!(target_os = "macos") { + "com.notey.app" + } else { + "notey" + }; + let expected = dirs::config_dir() + .expect("platform config dir must resolve") + .join(namespace); + assert_eq!( + dir, expected, + "config dir must be the platform config dir plus the Notey namespace" + ); +} + +/// AC 8.6/FR58: config-path resolution has a single source of truth — the live +/// `services::config::config_dir` returns the same path as the trait method. +#[test] +fn config_dir_matches_services_config() { + let via_service = + notey_lib::services::config::config_dir().expect("services config_dir must resolve"); + let via_trait = platform::current() + .config_dir() + .expect("platform config_dir must resolve"); + assert_eq!( + via_service, via_trait, + "services::config::config_dir must delegate to the Platform trait" + ); +} + +/// AC 8.6/FR58: the log directory is a per-user, platform-standard path. +#[test] +fn log_dir_is_user_scoped_and_standard() { + let dir = platform::current().log_dir().expect("log_dir must resolve"); + #[cfg(target_os = "linux")] + let expected = dirs::state_dir() + .expect("platform state dir must resolve") + .join("notey") + .join("logs"); + #[cfg(target_os = "macos")] + let expected = dirs::home_dir() + .expect("home dir must resolve") + .join("Library") + .join("Logs") + .join("com.notey.app"); + #[cfg(target_os = "windows")] + let expected = dirs::data_local_dir() + .expect("local data dir must resolve") + .join("notey") + .join("logs"); + assert_eq!( + dir, expected, + "log dir must be the platform-standard log path" + ); +} + +/// AC 8.6/FR56: macOS and Windows expose a single standard global-shortcut +/// backend (no Wayland branch). +#[cfg(not(target_os = "linux"))] +#[test] +fn hotkey_uses_standard_backend() { + let backend = platform::current() + .register_hotkey("Ctrl+Shift+N") + .expect("hotkey backend must resolve"); + assert_eq!(backend, platform::HotkeyBackend::Standard); } /// AC 8.5/FR51: the IPC socket path is user-scoped (no system-wide shared path). #[cfg(unix)] #[test] -#[ignore = "red-phase: Story 8.5"] fn socket_path_is_user_scoped() { let path = platform::current().socket_path(); let s = path.to_string_lossy(); - assert!(s.contains("notey"), "socket path must be namespaced to notey: {s}"); + assert!( + s.contains("notey"), + "socket path must be namespaced to notey: {s}" + ); let runtime = std::env::var("XDG_RUNTIME_DIR").unwrap_or_default(); if !runtime.is_empty() { assert!( @@ -68,22 +206,47 @@ fn socket_path_is_user_scoped() { /// standard plugin backend. #[cfg(target_os = "linux")] #[test] -#[ignore = "red-phase: Story 8.6"] fn linux_hotkey_uses_standard_backend_on_x11() { + let _guard = HOTKEY_ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner()); + let _display = EnvVarGuard::set("DISPLAY", ":99"); + let _wayland_display = EnvVarGuard::unset("WAYLAND_DISPLAY"); + let _session_type = EnvVarGuard::set("XDG_SESSION_TYPE", "x11"); + let backend = platform::current() .register_hotkey("Ctrl+Shift+N") .expect("hotkey registration must succeed on X11"); assert_eq!(backend, platform::HotkeyBackend::Standard); } +/// AC 8.6/FR57: pure Wayland without XWayland degrades gracefully instead of +/// pretending the standard X11 backend is available. +#[cfg(target_os = "linux")] +#[test] +fn linux_hotkey_errors_on_pure_wayland_without_xwayland() { + let _guard = HOTKEY_ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner()); + let _display = EnvVarGuard::set("DISPLAY", ""); + let _wayland_display = EnvVarGuard::set("WAYLAND_DISPLAY", "wayland-0"); + let _session_type = EnvVarGuard::set("XDG_SESSION_TYPE", "wayland"); + + let error = platform::current() + .register_hotkey("Ctrl+Shift+N") + .expect_err("pure Wayland without XWayland must report no standard backend"); + assert!( + error + .to_string() + .contains("Wayland compositor without XWayland"), + "unexpected pure-Wayland error: {error}" + ); +} + /// AC 8.6/FR57: when the standard plugin fails under Wayland, registration falls /// back to the XDG GlobalShortcuts portal. /// -/// NOTE: requires a Wayland session/harness to exercise the fallback path; until -/// then this documents the expected backend selection. +/// NOTE: native portal support is deferred to DW-96; this test remains ignored +/// until the ashpd-backed implementation and a Wayland harness exist. #[cfg(target_os = "linux")] #[test] -#[ignore = "red-phase: Story 8.6 (needs Wayland harness)"] +#[ignore = "DW-96: native Wayland portal support needs a Wayland harness"] fn linux_hotkey_falls_back_to_wayland_portal() { let backend = platform::current() .register_hotkey("Ctrl+Shift+N") @@ -94,7 +257,6 @@ fn linux_hotkey_falls_back_to_wayland_portal() { /// AC 8.2/FR54: on macOS the accessibility permission is queried during onboarding. #[cfg(target_os = "macos")] #[test] -#[ignore = "red-phase: Story 8.2"] fn macos_reports_accessibility_permission() { // Must not panic and must return a definite grant state. let _granted = platform::current() @@ -105,7 +267,6 @@ fn macos_reports_accessibility_permission() { /// AC 8.2: opening the accessibility settings pane is available on macOS. #[cfg(target_os = "macos")] #[test] -#[ignore = "red-phase: Story 8.2"] fn macos_can_open_accessibility_settings() { platform::current() .open_accessibility_settings() @@ -116,7 +277,6 @@ fn macos_can_open_accessibility_settings() { /// skipped entirely" — non-macOS platforms always report the permission as granted. #[cfg(not(target_os = "macos"))] #[test] -#[ignore = "red-phase: Story 8.2"] fn non_macos_skips_accessibility_gate() { assert!( platform::current() diff --git a/src-tauri/tests/search_tests.rs b/src-tauri/tests/search_tests.rs index ab30118..d57ae20 100644 --- a/src-tauri/tests/search_tests.rs +++ b/src-tauri/tests/search_tests.rs @@ -3,9 +3,9 @@ mod helpers; use rusqlite::params; use helpers::factories::{create_temp_db, NoteBuilder}; -use tauri_app_lib::db; -use tauri_app_lib::services::notes; -use tauri_app_lib::services::search_service; +use notey_lib::db; +use notey_lib::services::notes; +use notey_lib::services::search_service; // P0-INT-005b: FTS5 virtual table and all 3 triggers exist in sqlite_master #[test] diff --git a/src-tauri/tests/workspace_tests.rs b/src-tauri/tests/workspace_tests.rs index c7bd7ce..7a1b285 100644 --- a/src-tauri/tests/workspace_tests.rs +++ b/src-tauri/tests/workspace_tests.rs @@ -1,8 +1,8 @@ mod helpers; use helpers::factories::{create_temp_db, setup_test_db, NoteBuilder}; -use tauri_app_lib::errors::NoteyError; -use tauri_app_lib::services::workspace_service; +use notey_lib::errors::NoteyError; +use notey_lib::services::workspace_service; use tempfile::TempDir; // UNIT-2.1-001: workspaces table created with correct schema by migration @@ -167,7 +167,7 @@ fn test_migration_applies_on_existing_db_with_notes() { // Verify re-init doesn't break anything drop(conn); - let conn2 = tauri_app_lib::db::init_db(dir.path().to_path_buf()).expect("re-init failed"); + let conn2 = notey_lib::db::init_db(dir.path().to_path_buf()).expect("re-init failed"); let note_count2: i64 = conn2 .query_row("SELECT COUNT(*) FROM notes", [], |row| row.get(0)) .expect("count notes after re-init"); @@ -674,7 +674,7 @@ fn test_resolve_workspace_then_create_note_with_workspace_id() { let ws = workspace_service::resolve_workspace(&conn, dir.path().to_str().unwrap()) .expect("resolve_workspace failed"); - let note = tauri_app_lib::services::notes::create_note(&conn, "markdown", Some(ws.id)) + let note = notey_lib::services::notes::create_note(&conn, "markdown", Some(ws.id)) .expect("create_note failed"); assert_eq!( @@ -685,7 +685,7 @@ fn test_resolve_workspace_then_create_note_with_workspace_id() { // Verify via independent get_note let fetched = - tauri_app_lib::services::notes::get_note(&conn, note.id).expect("get_note failed"); + notey_lib::services::notes::get_note(&conn, note.id).expect("get_note failed"); assert_eq!( fetched.workspace_id, Some(ws.id), @@ -722,7 +722,7 @@ fn test_list_notes_filtered_by_workspace_integration() { .insert(&conn); let _note_null = NoteBuilder::new().title("Unscoped").insert(&conn); // workspace_id = NULL - let result = tauri_app_lib::services::notes::list_notes(&conn, Some(ws_a.id)) + let result = notey_lib::services::notes::list_notes(&conn, Some(ws_a.id)) .expect("list_notes filtered"); assert_eq!(result.len(), 2, "should return only notes in ws_a"); assert!( @@ -758,7 +758,7 @@ fn test_list_notes_filtered_excludes_trashed_integration() { .trashed() .insert(&conn); - let result = tauri_app_lib::services::notes::list_notes(&conn, Some(ws.id)) + let result = notey_lib::services::notes::list_notes(&conn, Some(ws.id)) .expect("list_notes filtered"); assert_eq!(result.len(), 1, "trashed note should be excluded"); assert_eq!(result[0].title, "Active"); @@ -779,7 +779,7 @@ fn test_list_notes_preserves_workspace_id() { .insert(&conn); NoteBuilder::new().title("Unscoped").insert(&conn); - let notes = tauri_app_lib::services::notes::list_notes(&conn, None).expect("list_notes failed"); + let notes = notey_lib::services::notes::list_notes(&conn, None).expect("list_notes failed"); assert_eq!(notes.len(), 2); let scoped = notes @@ -810,12 +810,12 @@ fn test_update_note_preserves_workspace_id() { let ws = workspace_service::create_workspace(&conn, "Project", dir.path().to_str().unwrap()) .expect("create_workspace failed"); - let note = tauri_app_lib::services::notes::create_note(&conn, "markdown", Some(ws.id)) + let note = notey_lib::services::notes::create_note(&conn, "markdown", Some(ws.id)) .expect("create_note failed"); assert_eq!(note.workspace_id, Some(ws.id)); // Update title and content — workspace_id should remain unchanged - let updated = tauri_app_lib::services::notes::update_note( + let updated = notey_lib::services::notes::update_note( &conn, note.id, Some("Updated Title".to_string()), diff --git a/src/App.tsx b/src/App.tsx index dde3ad6..3aeaca7 100644 --- a/src/App.tsx +++ b/src/App.tsx @@ -4,6 +4,8 @@ import { Toaster } from './features/toast/components/Toaster'; import { useWorkspaceStore } from './features/workspace/store'; import { restoreSession, startSessionAutoSave } from './features/session/persistence'; import { startNoteCreatedSync } from './features/note-list/realtimeSync'; +import { initOnboarding } from './features/onboarding/bootstrap'; +import { startHotkeyUnavailableNotice } from './features/hotkey/unavailableNotice'; /** Application root — renders the main CaptureWindow and the toast overlay. */ function App() { @@ -13,6 +15,16 @@ function App() { let stopNoteSync: (() => void) | null = null; const noteSyncReady = startNoteCreatedSync(); + // First-run onboarding: load persisted state (shows the overlay on first run) + // and record this session for the progressive command hint. Independent of + // the workspace/session chain below — failures must not block startup. + void initOnboarding(); + + // If no global-shortcut backend is available on this session, warn the user + // (via a persistent toast) that the hotkey will not work (FR57, DW-99). + // Best-effort and independent of the chain below. + void startHotkeyUnavailableNotice(); + // Attempt workspace init first, then restore the saved session. Auto-save // still starts if either step fails so session persistence keeps working. void (async () => { diff --git a/src/features/command-palette/actions.test.ts b/src/features/command-palette/actions.test.ts index fcd42e4..8fa0809 100644 --- a/src/features/command-palette/actions.test.ts +++ b/src/features/command-palette/actions.test.ts @@ -7,12 +7,14 @@ import * as autoSave from '../editor/hooks/useAutoSave'; import { useToastStore } from '../toast/store'; import { useWorkspaceStore } from '../workspace/store'; import { useSearchStore } from '../search/store'; +import { useSettingsStore } from '../settings/store'; import { createNewNote, trashActiveNote, toggleTheme, toggleFormat, toggleLayoutMode, + toggleAutostart, openSearch, stubAction, applyStartupConfig, @@ -1220,3 +1222,71 @@ describe('applyBootTheme', () => { expect(document.documentElement.getAttribute('data-theme')).toBe('light'); }); }); + +describe('toggleAutostart', () => { + beforeEach(() => { + useSettingsStore.getState().resetSettings(); + }); + + it('flips the live preference and persists via set_autostart', async () => { + mockInvoke.mockImplementation((cmd: string) => { + if (cmd === 'get_config') + return Promise.resolve(buildConfig({ general: { theme: 'dark', layoutMode: 'floating', autoStart: false } })); + if (cmd === 'get_autostart') return Promise.resolve(false); + if (cmd === 'set_autostart') + return Promise.resolve(buildConfig({ general: { theme: 'dark', layoutMode: 'floating', autoStart: true } })); + return Promise.reject(new Error(`unmocked: ${cmd}`)); + }); + + await toggleAutostart(); + + expect(mockInvoke).toHaveBeenCalledWith('set_autostart', { enabled: true }); + expect(useSettingsStore.getState().config?.general?.autoStart).toBe(true); + }); + + it('uses live OS state when it differs from the persisted preference', async () => { + mockInvoke.mockImplementation((cmd: string) => { + if (cmd === 'get_config') + return Promise.resolve(buildConfig({ general: { theme: 'dark', layoutMode: 'floating', autoStart: true } })); + if (cmd === 'get_autostart') return Promise.resolve(false); + if (cmd === 'set_autostart') + return Promise.resolve(buildConfig({ general: { theme: 'dark', layoutMode: 'floating', autoStart: true } })); + return Promise.reject(new Error(`unmocked: ${cmd}`)); + }); + + await toggleAutostart(); + + expect(mockInvoke).toHaveBeenCalledWith('set_autostart', { enabled: true }); + }); + + it('does not persist when getConfig fails', async () => { + const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); + mockInvoke.mockImplementation((cmd: string) => { + if (cmd === 'get_config') return Promise.reject({ type: 'Database' }); + return Promise.reject(new Error(`unmocked: ${cmd}`)); + }); + + await toggleAutostart(); + + expect(mockInvoke).not.toHaveBeenCalledWith('set_autostart', expect.anything()); + consoleSpy.mockRestore(); + }); + + it('coalesces concurrent invocations (singleflight)', async () => { + let getConfigCalls = 0; + mockInvoke.mockImplementation((cmd: string) => { + if (cmd === 'get_config') { + getConfigCalls += 1; + return Promise.resolve(buildConfig({ general: { theme: 'dark', layoutMode: 'floating', autoStart: false } })); + } + if (cmd === 'get_autostart') return Promise.resolve(false); + if (cmd === 'set_autostart') + return Promise.resolve(buildConfig({ general: { theme: 'dark', layoutMode: 'floating', autoStart: true } })); + return Promise.reject(new Error(`unmocked: ${cmd}`)); + }); + + await Promise.all([toggleAutostart(), toggleAutostart()]); + + expect(getConfigCalls).toBe(1); + }); +}); diff --git a/src/features/command-palette/actions.ts b/src/features/command-palette/actions.ts index cec5207..d107ed9 100644 --- a/src/features/command-palette/actions.ts +++ b/src/features/command-palette/actions.ts @@ -8,6 +8,7 @@ import { flushSave } from '../editor/hooks/useAutoSave'; import { normalizeLayoutMode, nextLayoutMode } from '../settings/layoutMode'; import { useSettingsStore } from '../settings/store'; import { singleflight } from '../../lib/singleflight'; +import { withTimeout } from '../../lib/withTimeout'; /** * Create a new note, open it in a tab, and load it into the editor. @@ -25,23 +26,30 @@ export async function createNewNote(): Promise { const format = useEditorStore.getState().format; const workspaceId = useWorkspaceStore.getState().activeWorkspaceId; - const result = await commands.createNote(format, workspaceId); - if (result.status === 'error') { - console.error('createNote failed:', result.error); - return; - } - - const note = result.data; - useTabStore.getState().openTab(note.id, 'New note'); + try { + const result = await withTimeout(commands.createNote(format, workspaceId), { + label: 'create_note', + }); + if (result.status === 'error') { + console.error('createNote failed:', result.error); + return; + } - await useEditorStore.getState().loadNote(note.id); - // loadNote sets saveStatus to 'failed' on error — close the orphaned tab - if (useEditorStore.getState().saveStatus === 'failed') { - const { tabs } = useTabStore.getState(); - const tabIndex = tabs.findIndex((t) => t.noteId === note.id); - if (tabIndex !== -1) { - useTabStore.getState().closeTab(tabIndex); + const note = result.data; + useTabStore.getState().openTab(note.id, 'New note'); + + await useEditorStore.getState().loadNote(note.id); + // loadNote sets saveStatus to 'failed' on error — close the orphaned tab + if (useEditorStore.getState().saveStatus === 'failed') { + const { tabs } = useTabStore.getState(); + const tabIndex = tabs.findIndex((t) => t.noteId === note.id); + if (tabIndex !== -1) { + useTabStore.getState().closeTab(tabIndex); + } } + } catch (error) { + console.error('createNote threw:', error); + return; } }); } @@ -247,7 +255,9 @@ function bindSystemThemeListener(): void { async function applyLayoutModeToWindow(layoutMode: string): Promise { const mode = normalizeLayoutMode(layoutMode); try { - const result = await commands.applyLayoutMode(mode); + const result = await withTimeout(commands.applyLayoutMode(mode), { + label: 'apply_layout_mode', + }); if (result.status === 'error') { console.error('applyLayoutMode failed:', result.error); return false; @@ -298,7 +308,9 @@ function applyFontFamily(family: string): void { async function persistSettingsUpdate(partial: PartialAppConfig, context: string): Promise { const save = async () => { try { - const result = await commands.updateConfig(partial); + const result = await withTimeout(commands.updateConfig(partial), { + label: 'update_config', + }); if (result.status === 'error') { console.error(`updateConfig failed in ${context}:`, result.error); return false; @@ -370,32 +382,78 @@ export async function applyStartupConfig(): Promise { */ export async function toggleTheme(): Promise { await singleflight('toggle-theme', async () => { - const configResult = await commands.getConfig(); - if (configResult.status === 'error') { - console.error('getConfig failed:', configResult.error); + try { + const configResult = await withTimeout(commands.getConfig(), { + label: 'get_config', + }); + if (configResult.status === 'error') { + console.error('getConfig failed:', configResult.error); + return; + } + + const current = configResult.data.general?.theme ?? 'dark'; + const currentIsDark = current === 'dark' || (current === 'system' && systemPrefersDark()); + const next = currentIsDark ? 'light' : 'dark'; + + const updateResult = await withTimeout( + commands.updateConfig({ + general: { theme: next, layoutMode: null }, + editor: null, + hotkey: null, + shortcuts: null, + }), + { label: 'update_config' }, + ); + if (updateResult.status === 'error') { + console.error('updateConfig failed:', updateResult.error); + return; + } + + // Mark theme as user-controlled before applying, so a concurrent startup + // application (still awaiting its getConfig) will skip it. Set only on the + // success path — a failed toggle must not suppress startup application. + userToggled.theme = true; + applyThemeClass(next); + } catch (error) { + console.error('toggleTheme threw:', error); return; } + }); +} - const current = configResult.data.general?.theme ?? 'dark'; - const currentIsDark = current === 'dark' || (current === 'system' && systemPrefersDark()); - const next = currentIsDark ? 'light' : 'dark'; +/** + * Toggle auto-start on login (Story 8.4). Reads persisted config, reconciles to + * the live OS registration when available, then delegates to the settings store's + * `setAutostart` (plugin registration + persistence + toast). Guarded against + * concurrent invocations (e.g. key repeat) to avoid a lost-update race. + */ +export async function toggleAutostart(): Promise { + await singleflight('toggle-autostart', async () => { + try { + const configResult = await withTimeout(commands.getConfig(), { + label: 'get_config', + }); + if (configResult.status === 'error') { + console.error('getConfig failed:', configResult.error); + return; + } - const updateResult = await commands.updateConfig({ - general: { theme: next, layoutMode: null }, - editor: null, - hotkey: null, - shortcuts: null, - }); - if (updateResult.status === 'error') { - console.error('updateConfig failed:', updateResult.error); + let current = configResult.data.general?.autoStart ?? false; + const liveResult = await withTimeout(commands.getAutostart(), { + label: 'get_autostart', + }); + if (liveResult.status === 'ok') { + current = liveResult.data; + } else { + console.error('getAutostart failed:', liveResult.error); + } + + const next = !current; + await useSettingsStore.getState().setAutostart(next); + } catch (error) { + console.error('toggleAutostart threw:', error); return; } - - // Mark theme as user-controlled before applying, so a concurrent startup - // application (still awaiting its getConfig) will skip it. Set only on the - // success path — a failed toggle must not suppress startup application. - userToggled.theme = true; - applyThemeClass(next); }); } @@ -414,29 +472,39 @@ export function toggleFormat(): void { */ export async function toggleLayoutMode(): Promise { await singleflight('toggle-layout-mode', async () => { - const configResult = await commands.getConfig(); - if (configResult.status === 'error') { - console.error('getConfig failed:', configResult.error); - return; - } + try { + const configResult = await withTimeout(commands.getConfig(), { + label: 'get_config', + }); + if (configResult.status === 'error') { + console.error('getConfig failed:', configResult.error); + return; + } - const next = nextLayoutMode(configResult.data.general?.layoutMode); + const next = nextLayoutMode(configResult.data.general?.layoutMode); + + const updateResult = await withTimeout( + commands.updateConfig({ + general: { theme: null, layoutMode: next }, + editor: null, + hotkey: null, + shortcuts: null, + }), + { label: 'update_config' }, + ); + if (updateResult.status === 'error') { + console.error('updateConfig failed:', updateResult.error); + return; + } - const updateResult = await commands.updateConfig({ - general: { theme: null, layoutMode: next }, - editor: null, - hotkey: null, - shortcuts: null, - }); - if (updateResult.status === 'error') { - console.error('updateConfig failed:', updateResult.error); + // Mark layout as user-controlled before applying (see toggleTheme). Success + // path only, so a failed toggle does not suppress startup application. + userToggled.layoutMode = true; + await applyLayoutModeToWindow(next); + } catch (error) { + console.error('toggleLayoutMode threw:', error); return; } - - // Mark layout as user-controlled before applying (see toggleTheme). Success - // path only, so a failed toggle does not suppress startup application. - userToggled.layoutMode = true; - await applyLayoutModeToWindow(next); }); } diff --git a/src/features/command-palette/hooks/usePaletteCommands.test.ts b/src/features/command-palette/hooks/usePaletteCommands.test.ts index ee895a6..2e40105 100644 --- a/src/features/command-palette/hooks/usePaletteCommands.test.ts +++ b/src/features/command-palette/hooks/usePaletteCommands.test.ts @@ -3,9 +3,9 @@ import { usePaletteCommands } from './usePaletteCommands'; import { useSettingsStore } from '../../settings/store'; describe('usePaletteCommands', () => { - it('returns 12 commands total', () => { + it('returns 13 commands total', () => { const commands = usePaletteCommands(); - expect(commands).toHaveLength(12); + expect(commands).toHaveLength(13); }); it('includes all three groups', () => { @@ -35,14 +35,15 @@ describe('usePaletteCommands', () => { expect(nav.map((c) => c.label)).toEqual(['Open Note List', 'View Trash']); }); - it('has 6 settings commands', () => { + it('has 7 settings commands', () => { const commands = usePaletteCommands(); const settings = commands.filter((c) => c.group === 'Settings'); - expect(settings).toHaveLength(6); + expect(settings).toHaveLength(7); expect(settings.map((c) => c.label)).toEqual([ 'Toggle Theme', 'Toggle Layout Mode', 'Toggle Format', + 'Toggle Auto-Start on Login', 'Open Settings', 'Export to Markdown', 'Export to JSON', diff --git a/src/features/command-palette/hooks/usePaletteCommands.ts b/src/features/command-palette/hooks/usePaletteCommands.ts index b31c442..69cb023 100644 --- a/src/features/command-palette/hooks/usePaletteCommands.ts +++ b/src/features/command-palette/hooks/usePaletteCommands.ts @@ -5,6 +5,7 @@ import { toggleTheme, toggleFormat, toggleLayoutMode, + toggleAutostart, trashActiveNote, stubAction, } from "../actions"; @@ -103,6 +104,13 @@ export function usePaletteCommands(): PaletteCommand[] { shortcut: "", action: toggleFormat, }, + { + id: "toggle-autostart", + label: "Toggle Auto-Start on Login", + group: "Settings", + shortcut: "", + action: toggleAutostart, + }, { id: "open-settings", label: "Open Settings", diff --git a/src/features/editor/components/CaptureWindow.tsx b/src/features/editor/components/CaptureWindow.tsx index 4062c0e..05c153a 100644 --- a/src/features/editor/components/CaptureWindow.tsx +++ b/src/features/editor/components/CaptureWindow.tsx @@ -13,6 +13,7 @@ import { TrashPanel } from '../../trash/components/TrashPanel'; import { useTrashStore } from '../../trash/store'; import { SettingsPanel } from '../../settings/components/SettingsPanel'; import { useSettingsStore } from '../../settings/store'; +import { OnboardingOverlay } from '../../onboarding/components/OnboardingOverlay'; import { matchesShortcut } from '../../settings/shortcuts'; import { createNewNote, toggleTheme } from '../../command-palette/actions'; @@ -136,6 +137,7 @@ export function CaptureWindow() { {isNoteListOpen && } {isTrashOpen && } {isSettingsOpen && } + diff --git a/src/features/editor/components/StatusBar.test.tsx b/src/features/editor/components/StatusBar.test.tsx index 8109370..a41c116 100644 --- a/src/features/editor/components/StatusBar.test.tsx +++ b/src/features/editor/components/StatusBar.test.tsx @@ -1,25 +1,49 @@ -import { describe, it, expect } from 'vitest'; +import { describe, it, expect, beforeEach } from 'vitest'; import { render, screen } from '@testing-library/react'; import { useWorkspaceStore } from '../../workspace/store'; +import { useOnboardingStore } from '../../onboarding/store'; import { StatusBar } from './StatusBar'; const MOCK_WORKSPACES = [ - { id: 1, name: 'my-project', path: '/p', createdAt: '2026-01-01T00:00:00+00:00', noteCount: 4 }, - { id: 2, name: 'other', path: '/o', createdAt: '2026-01-02T00:00:00+00:00', noteCount: 6 }, + { + id: 1, + name: 'my-project', + path: '/p', + createdAt: '2026-01-01T00:00:00+00:00', + noteCount: 4, + }, + { + id: 2, + name: 'other', + path: '/o', + createdAt: '2026-01-02T00:00:00+00:00', + noteCount: 6, + }, ]; describe('StatusBar', () => { + beforeEach(() => { + useOnboardingStore.getState().reset(); + }); it('renders "No workspace" when no workspace is active', () => { render(); - expect(screen.getByTestId('workspace-name')).toHaveTextContent('No workspace'); + expect(screen.getByTestId('workspace-name')).toHaveTextContent( + 'No workspace', + ); }); it('renders workspace name with note count in "[name] \u00b7 [N] notes" format', () => { const mockNotes = Array.from({ length: 4 }, (_, i) => ({ - id: i + 1, title: `Note ${i}`, content: '', format: 'markdown', - workspaceId: 1, createdAt: '2026-01-01T00:00:00+00:00', - updatedAt: '2026-01-01T00:00:00+00:00', deletedAt: null, isTrashed: false, + id: i + 1, + title: `Note ${i}`, + content: '', + format: 'markdown', + workspaceId: 1, + createdAt: '2026-01-01T00:00:00+00:00', + updatedAt: '2026-01-01T00:00:00+00:00', + deletedAt: null, + isTrashed: false, })); useWorkspaceStore.setState({ activeWorkspaceId: 1, @@ -28,14 +52,22 @@ describe('StatusBar', () => { filteredNotes: mockNotes, }); render(); - expect(screen.getByTestId('workspace-name')).toHaveTextContent('my-project \u00b7 4 notes'); + expect(screen.getByTestId('workspace-name')).toHaveTextContent( + 'my-project \u00b7 4 notes', + ); }); it('renders "All Workspaces" with total note count when isAllWorkspaces is true', () => { const mockNotes = Array.from({ length: 10 }, (_, i) => ({ - id: i + 1, title: `Note ${i}`, content: '', format: 'markdown', - workspaceId: i < 4 ? 1 : 2, createdAt: '2026-01-01T00:00:00+00:00', - updatedAt: '2026-01-01T00:00:00+00:00', deletedAt: null, isTrashed: false, + id: i + 1, + title: `Note ${i}`, + content: '', + format: 'markdown', + workspaceId: i < 4 ? 1 : 2, + createdAt: '2026-01-01T00:00:00+00:00', + updatedAt: '2026-01-01T00:00:00+00:00', + deletedAt: null, + isTrashed: false, })); useWorkspaceStore.setState({ isAllWorkspaces: true, @@ -45,14 +77,22 @@ describe('StatusBar', () => { filteredNotes: mockNotes, }); render(); - expect(screen.getByTestId('workspace-name')).toHaveTextContent('All Workspaces \u00b7 10 notes'); + expect(screen.getByTestId('workspace-name')).toHaveTextContent( + 'All Workspaces \u00b7 10 notes', + ); }); it('renders singular "1 note" for single note count', () => { const singleNote = { - id: 1, title: 'Solo', content: '', format: 'markdown', - workspaceId: 1, createdAt: '2026-01-01T00:00:00+00:00', - updatedAt: '2026-01-01T00:00:00+00:00', deletedAt: null, isTrashed: false, + id: 1, + title: 'Solo', + content: '', + format: 'markdown', + workspaceId: 1, + createdAt: '2026-01-01T00:00:00+00:00', + updatedAt: '2026-01-01T00:00:00+00:00', + deletedAt: null, + isTrashed: false, }; useWorkspaceStore.setState({ activeWorkspaceId: 1, @@ -61,9 +101,13 @@ describe('StatusBar', () => { filteredNotes: [singleNote], }); render(); - expect(screen.getByTestId('workspace-name')).toHaveTextContent('my-project \u00b7 1 note'); + expect(screen.getByTestId('workspace-name')).toHaveTextContent( + 'my-project \u00b7 1 note', + ); // Verify it's NOT "1 notes" (plural) - expect(screen.getByTestId('workspace-name').textContent).not.toContain('1 notes'); + expect(screen.getByTestId('workspace-name').textContent).not.toContain( + '1 notes', + ); }); it('workspace trigger is clickable (button element)', () => { @@ -94,4 +138,20 @@ describe('StatusBar', () => { expect(toggle.style.display).toBe('flex'); expect(toggle.parentElement?.style.gap).toBe(''); }); + + it('renders the command hint only after onboarding state loads within the session limit', () => { + useOnboardingStore.setState({ initialized: false, sessionsSeen: 0 }); + const { rerender } = render(); + expect(screen.queryByTestId('command-hint')).not.toBeInTheDocument(); + + useOnboardingStore.setState({ initialized: true, sessionsSeen: 4 }); + rerender(); + expect(screen.getByTestId('command-hint')).toHaveTextContent( + 'Ctrl+P for commands', + ); + + useOnboardingStore.setState({ sessionsSeen: 5 }); + rerender(); + expect(screen.queryByTestId('command-hint')).not.toBeInTheDocument(); + }); }); diff --git a/src/features/editor/components/StatusBar.tsx b/src/features/editor/components/StatusBar.tsx index e5d84cf..689d0b3 100644 --- a/src/features/editor/components/StatusBar.tsx +++ b/src/features/editor/components/StatusBar.tsx @@ -2,6 +2,7 @@ import { commands } from '../../../generated/bindings'; import { useEditorStore } from '../store'; import { SaveIndicator } from './SaveIndicator'; import { WorkspaceSelector } from '../../workspace/components/WorkspaceSelector'; +import { useOnboardingStore } from '../../onboarding/store'; import type { NoteFormat } from '../store'; /** @@ -12,6 +13,9 @@ export function StatusBar() { const format = useEditorStore((s) => s.format); const activeNoteId = useEditorStore((s) => s.activeNoteId); const setFormat = useEditorStore((s) => s.setFormat); + // Progressive disclosure (Story 8.1): show a "Ctrl+P for commands" hint during + // the user's first 5 sessions, then retire it permanently. + const showCommandHint = useOnboardingStore((s) => s.shouldShowCommandHint()); async function handleFormatToggle() { const newFormat: NoteFormat = format === 'markdown' ? 'plaintext' : 'markdown'; @@ -43,6 +47,18 @@ export function StatusBar() { >
+ {showCommandHint && ( + + Ctrl+P for commands + + )} +

+ You can skip this, but the shortcut may not work without this + permission. +

+ +
+ ) : customizing ? ( +
+

+ Press your preferred shortcut… +

+
+ {captured === null ? ( + + Waiting for a key combination… + + ) : ( + captured + .split('+') + .map((part) => part.trim()) + .filter(Boolean) + .map((cap) => ( + + {cap} + + )) + )} +
+ {warning !== null && ( +

+ {warning} +

+ )} +
+ + +
+
+ ) : ( +
+

+ Your capture shortcut is +

+
+ {keyCaps.map((cap) => ( + + {cap} + + ))} +
+

+ Press it now to try +

+ +
+ )} + + + ); } + +const onboardingButtonStyle = { + cursor: 'pointer', + color: 'var(--text-secondary)', + background: 'var(--bg-primary)', + border: '1px solid var(--border-default)', + borderRadius: '4px', + padding: '6px 12px', + fontSize: '13px', +} as const; diff --git a/src/features/onboarding/store.test.ts b/src/features/onboarding/store.test.ts index 880670d..835cd37 100644 --- a/src/features/onboarding/store.test.ts +++ b/src/features/onboarding/store.test.ts @@ -1,5 +1,6 @@ import { describe, it, expect, beforeEach, vi } from 'vitest'; import { useOnboardingStore, COMMAND_HINT_SESSION_LIMIT } from './store'; +import { useSettingsStore } from '../settings/store'; import * as api from './api'; /** @@ -9,14 +10,17 @@ import * as api from './api'; * stubbed `./api`, which throws until the green phase). Activate by switching * `describe.skip` → `describe` once `./api` is wired to the generated bindings. */ -describe.skip('useOnboardingStore (red-phase: Stories 8.1, 8.3)', () => { +describe('useOnboardingStore (red-phase: Stories 8.1, 8.3)', () => { beforeEach(() => { useOnboardingStore.getState().reset(); vi.restoreAllMocks(); }); it('shows the overlay on first run and seeds the hotkey (8.1)', async () => { - vi.spyOn(api, 'loadOnboardingState').mockResolvedValue({ complete: false, sessionsSeen: 0 }); + vi.spyOn(api, 'loadOnboardingState').mockResolvedValue({ + complete: false, + sessionsSeen: 0, + }); await useOnboardingStore.getState().init('Ctrl+Shift+N'); @@ -26,7 +30,10 @@ describe.skip('useOnboardingStore (red-phase: Stories 8.1, 8.3)', () => { }); it('keeps the overlay hidden when onboarding is already complete (8.1)', async () => { - vi.spyOn(api, 'loadOnboardingState').mockResolvedValue({ complete: true, sessionsSeen: 3 }); + vi.spyOn(api, 'loadOnboardingState').mockResolvedValue({ + complete: true, + sessionsSeen: 3, + }); await useOnboardingStore.getState().init('Ctrl+Shift+N'); @@ -43,29 +50,85 @@ describe.skip('useOnboardingStore (red-phase: Stories 8.1, 8.3)', () => { expect(useOnboardingStore.getState().isVisible).toBe(false); }); + it('dismiss logs persistence failure but still hides the overlay (8.1)', async () => { + vi.spyOn(api, 'completeOnboarding').mockRejectedValue( + new Error('disk full'), + ); + const consoleError = vi + .spyOn(console, 'error') + .mockImplementation(() => undefined); + useOnboardingStore.setState({ isVisible: true, customizing: true }); + + await useOnboardingStore.getState().dismiss(); + + expect(consoleError).toHaveBeenCalledWith( + 'completeOnboarding failed during dismiss:', + expect.any(Error), + ); + expect(useOnboardingStore.getState().isVisible).toBe(false); + expect(useOnboardingStore.getState().customizing).toBe(false); + }); + it('startCustomize enters capture mode (8.3)', () => { useOnboardingStore.getState().startCustomize(); expect(useOnboardingStore.getState().customizing).toBe(true); }); - it('applyCustomHotkey updates the displayed shortcut and exits capture mode (8.3)', () => { + it('cancelCustomize leaves capture mode without changing the shortcut (8.3)', () => { + useOnboardingStore.setState({ customizing: true, hotkey: 'Ctrl+Shift+N' }); + + useOnboardingStore.getState().cancelCustomize(); + + const s = useOnboardingStore.getState(); + expect(s.customizing).toBe(false); + expect(s.hotkey).toBe('Ctrl+Shift+N'); + }); + + it('applyCustomHotkey registers via the shared path, then adopts the shortcut and exits capture (8.3)', async () => { + const setGlobalShortcut = vi + .spyOn(useSettingsStore.getState(), 'setGlobalShortcut') + .mockResolvedValue(true); useOnboardingStore.setState({ customizing: true, hotkey: 'Ctrl+Shift+N' }); - useOnboardingStore.getState().applyCustomHotkey('Alt+Space'); + const ok = await useOnboardingStore.getState().applyCustomHotkey('Ctrl+Shift+J'); + expect(setGlobalShortcut).toHaveBeenCalledWith('Ctrl+Shift+J'); + expect(ok).toBe(true); const s = useOnboardingStore.getState(); - expect(s.hotkey).toBe('Alt+Space'); + expect(s.hotkey).toBe('Ctrl+Shift+J'); expect(s.customizing).toBe(false); }); + it('applyCustomHotkey keeps the old shortcut and stays in capture on a conflict (8.3)', async () => { + vi.spyOn(useSettingsStore.getState(), 'setGlobalShortcut').mockResolvedValue( + false, + ); + useOnboardingStore.setState({ customizing: true, hotkey: 'Ctrl+Shift+N' }); + + const ok = await useOnboardingStore.getState().applyCustomHotkey('Ctrl+Shift+J'); + + expect(ok).toBe(false); + const s = useOnboardingStore.getState(); + expect(s.hotkey).toBe('Ctrl+Shift+N'); + expect(s.customizing).toBe(true); + }); + it('shows the command hint only within the first 5 sessions (8.1)', () => { - useOnboardingStore.setState({ sessionsSeen: COMMAND_HINT_SESSION_LIMIT - 1 }); + useOnboardingStore.setState({ + initialized: true, + sessionsSeen: COMMAND_HINT_SESSION_LIMIT - 1, + }); expect(useOnboardingStore.getState().shouldShowCommandHint()).toBe(true); useOnboardingStore.setState({ sessionsSeen: COMMAND_HINT_SESSION_LIMIT }); expect(useOnboardingStore.getState().shouldShowCommandHint()).toBe(false); }); + it('does not show the command hint before onboarding state loads (8.1)', () => { + useOnboardingStore.setState({ initialized: false, sessionsSeen: 0 }); + expect(useOnboardingStore.getState().shouldShowCommandHint()).toBe(false); + }); + it('flags macOS accessibility guidance when required (8.2)', () => { useOnboardingStore.getState().setAccessibilityNeeded(true); expect(useOnboardingStore.getState().accessibilityNeeded).toBe(true); diff --git a/src/features/onboarding/store.ts b/src/features/onboarding/store.ts index d9ea6a7..ede7825 100644 --- a/src/features/onboarding/store.ts +++ b/src/features/onboarding/store.ts @@ -1,4 +1,5 @@ import { create } from 'zustand'; +import { useSettingsStore } from '../settings/store'; import { completeOnboarding, loadOnboardingState } from './api'; /** @@ -20,6 +21,8 @@ interface OnboardingStateShape { accessibilityNeeded: boolean; /** Persisted session count, used to retire the command hint. */ sessionsSeen: number; + /** Whether persisted onboarding state has been loaded for this session. */ + initialized: boolean; } /** Onboarding actions. */ @@ -33,8 +36,16 @@ interface OnboardingActions { dismiss: () => Promise; /** Enter hotkey capture mode (Story 8.3 "Customize"). */ startCustomize: () => void; - /** Apply a captured shortcut and leave capture mode (Story 8.3). */ - applyCustomHotkey: (combo: string) => void; + /** Leave hotkey capture mode without changing the shortcut (Story 8.3). */ + cancelCustomize: () => void; + /** + * Register + persist a captured shortcut through the shared Epic 7 path and, + * on success, adopt it as the displayed hotkey and leave capture mode (Story + * 8.3). On a conflict/failure the previous shortcut stays registered and + * capture mode is kept so the user can retry. Resolves `true` on success, + * `false` on conflict/error. + */ + applyCustomHotkey: (combo: string) => Promise; /** Set whether macOS accessibility guidance should be shown (Story 8.2). */ setAccessibilityNeeded: (needed: boolean) => void; /** Whether the early command-palette hint should still be shown. */ @@ -49,34 +60,53 @@ const INITIAL: OnboardingStateShape = { customizing: false, accessibilityNeeded: false, sessionsSeen: 0, + initialized: false, }; /** * Per-feature store for the first-run onboarding flow. * - * RED-PHASE NOTE: the orchestration here is real; it delegates persistence to the - * stubbed {@link import('./api')} bridge, which throws until the green phase. The - * `describe.skip` tests in `store.test.ts` assert these transitions. + * Persistence is delegated to the {@link import('./api')} bridge (onboarding + * completion + session count) and, for hotkey customization (Story 8.3), to the + * shared Settings {@link useSettingsStore.setGlobalShortcut} register-before-commit + * path. The transitions are asserted by `store.test.ts`. */ -export const useOnboardingStore = create( - (set, get) => ({ - ...INITIAL, - init: async (hotkey) => { - const state = await loadOnboardingState(); - set({ - hotkey, - sessionsSeen: state.sessionsSeen, - isVisible: !state.complete, - }); - }, - dismiss: async () => { +export const useOnboardingStore = create< + OnboardingStateShape & OnboardingActions +>((set, get) => ({ + ...INITIAL, + init: async (hotkey) => { + const state = await loadOnboardingState(); + set({ + hotkey, + sessionsSeen: state.sessionsSeen, + isVisible: !state.complete, + initialized: true, + }); + }, + dismiss: async () => { + try { await completeOnboarding(); + } catch (e) { + console.error('completeOnboarding failed during dismiss:', e); + } finally { set({ isVisible: false, customizing: false }); - }, - startCustomize: () => set({ customizing: true }), - applyCustomHotkey: (combo) => set({ hotkey: combo, customizing: false }), - setAccessibilityNeeded: (needed) => set({ accessibilityNeeded: needed }), - shouldShowCommandHint: () => get().sessionsSeen < COMMAND_HINT_SESSION_LIMIT, - reset: () => set({ ...INITIAL }), - }), -); + } + }, + startCustomize: () => set({ customizing: true }), + cancelCustomize: () => set({ customizing: false }), + applyCustomHotkey: async (combo) => { + // Reuse Settings' register-before-commit path (Epic 7): it validates, + // registers the new shortcut, unregisters the old, persists, and reports a + // conflict by resolving `false` — so onboarding never reimplements that logic. + const ok = await useSettingsStore.getState().setGlobalShortcut(combo); + if (ok) { + set({ hotkey: combo, customizing: false }); + } + return ok; + }, + setAccessibilityNeeded: (needed) => set({ accessibilityNeeded: needed }), + shouldShowCommandHint: () => + get().initialized && get().sessionsSeen < COMMAND_HINT_SESSION_LIMIT, + reset: () => set({ ...INITIAL }), +})); diff --git a/src/features/settings/components/SettingsPanel.test.tsx b/src/features/settings/components/SettingsPanel.test.tsx index bc63795..45da0ff 100644 --- a/src/features/settings/components/SettingsPanel.test.tsx +++ b/src/features/settings/components/SettingsPanel.test.tsx @@ -359,4 +359,31 @@ describe('SettingsPanel', () => { fireEvent.keyDown(first, { key: 'Tab', shiftKey: true }); expect(document.activeElement).toBe(screen.getByTestId('settings-done')); }); + + it('toggles auto-start on and persists via set_autostart (Story 8.4)', async () => { + const cfgOn = buildConfig({ general: { theme: 'system', layoutMode: 'floating', autoStart: true } }); + mockInvoke.mockImplementation((cmd: string) => { + if (cmd === 'get_config') + return Promise.resolve( + buildConfig({ general: { theme: 'system', layoutMode: 'floating', autoStart: false } }), + ); + if (cmd === 'get_autostart') return Promise.resolve(false); + if (cmd === 'set_autostart') return Promise.resolve(cfgOn); + return Promise.reject(new Error(`unmocked: ${cmd}`)); + }); + await useSettingsStore.getState().open(); + render(); + + const toggle = screen.getByTestId('autostart-toggle'); + expect(toggle).toHaveAttribute('aria-checked', 'false'); + + fireEvent.click(toggle); + + await waitFor(() => { + expect(mockInvoke).toHaveBeenCalledWith('set_autostart', { enabled: true }); + }); + await waitFor(() => { + expect(screen.getByTestId('autostart-toggle')).toHaveAttribute('aria-checked', 'true'); + }); + }); }); diff --git a/src/features/settings/components/SettingsPanel.tsx b/src/features/settings/components/SettingsPanel.tsx index c522d68..8a72396 100644 --- a/src/features/settings/components/SettingsPanel.tsx +++ b/src/features/settings/components/SettingsPanel.tsx @@ -57,6 +57,7 @@ export function SettingsPanel() { const setLayoutMode = useSettingsStore((s) => s.setLayoutMode); const setFontSize = useSettingsStore((s) => s.setFontSize); const setFontFamily = useSettingsStore((s) => s.setFontFamily); + const setAutostart = useSettingsStore((s) => s.setAutostart); const overlayRef = useRef(null); const firstControlRef = useRef(null); useFocusTrap(overlayRef, true); @@ -101,6 +102,7 @@ export function SettingsPanel() { const fontSize = clampFontSize(config?.editor?.fontSize ?? 14); const fontFamily = config?.editor?.fontFamily === 'sans' ? 'sans' : 'mono'; const globalShortcut = config?.hotkey?.globalShortcut ?? 'Ctrl+Shift+N'; + const autoStart = config?.general?.autoStart ?? false; return (
+ +
+ + Start on login + + +
{/* Editor */} diff --git a/src/features/settings/store.test.ts b/src/features/settings/store.test.ts index a4b6e86..8ff62ca 100644 --- a/src/features/settings/store.test.ts +++ b/src/features/settings/store.test.ts @@ -6,6 +6,14 @@ import { useSettingsStore } from './store'; import { useSearchStore } from '../search/store'; import { useToastStore } from '../toast/store'; +function deferred() { + let resolve!: (value: T) => void; + const promise = new Promise((res) => { + resolve = res; + }); + return { promise, resolve }; +} + describe('useSettingsStore', () => { beforeEach(() => { useSettingsStore.getState().resetSettings(); @@ -254,4 +262,78 @@ describe('useSettingsStore', () => { expect(ok).toBe(true); expect(useSettingsStore.getState().bindings.search).toBe('Ctrl+F'); }); + + it('setAutostart enables, persists via set_autostart, and adopts the returned config', async () => { + mockInvoke.mockImplementation((cmd: string) => { + if (cmd === 'get_config') + return Promise.resolve(buildConfig({ general: { theme: 'system', layoutMode: 'floating', autoStart: false } })); + if (cmd === 'get_autostart') return Promise.resolve(false); + if (cmd === 'set_autostart') + return Promise.resolve(buildConfig({ general: { theme: 'system', layoutMode: 'floating', autoStart: true } })); + return Promise.reject(new Error(`unmocked: ${cmd}`)); + }); + await useSettingsStore.getState().open(); + + const ok = await useSettingsStore.getState().setAutostart(true); + + expect(ok).toBe(true); + expect(mockInvoke).toHaveBeenCalledWith('set_autostart', { enabled: true }); + expect(useSettingsStore.getState().config?.general?.autoStart).toBe(true); + expect(useToastStore.getState().toasts.some((t) => t.message.includes('enabled'))).toBe(true); + }); + + it('setAutostart keeps the prior state and toasts on failure', async () => { + const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); + mockInvoke.mockImplementation((cmd: string) => { + if (cmd === 'get_config') + return Promise.resolve(buildConfig({ general: { theme: 'system', layoutMode: 'floating', autoStart: false } })); + if (cmd === 'get_autostart') return Promise.resolve(false); + if (cmd === 'set_autostart') return Promise.reject({ type: 'Config', message: 'boom' }); + return Promise.reject(new Error(`unmocked: ${cmd}`)); + }); + await useSettingsStore.getState().open(); + + const ok = await useSettingsStore.getState().setAutostart(true); + + expect(ok).toBe(false); + expect(useSettingsStore.getState().config?.general?.autoStart ?? false).toBe(false); + expect(useToastStore.getState().toasts.some((t) => t.message.includes('Couldn’t change auto-start'))).toBe(true); + consoleSpy.mockRestore(); + }); + + it('open() reconciles the toggle to the live OS auto-start state', async () => { + mockInvoke.mockImplementation((cmd: string) => { + if (cmd === 'get_config') + return Promise.resolve(buildConfig({ general: { theme: 'system', layoutMode: 'floating', autoStart: false } })); + if (cmd === 'get_autostart') return Promise.resolve(true); // OS reports enabled + return Promise.reject(new Error(`unmocked: ${cmd}`)); + }); + + await useSettingsStore.getState().open(); + + expect(useSettingsStore.getState().config?.general?.autoStart).toBe(true); + }); + + it('ignores stale open() auto-start reconciliation after a completed toggle', async () => { + const liveState = deferred(); + mockInvoke.mockImplementation((cmd: string) => { + if (cmd === 'get_config') + return Promise.resolve(buildConfig({ general: { theme: 'system', layoutMode: 'floating', autoStart: false } })); + if (cmd === 'get_autostart') return liveState.promise; + if (cmd === 'set_autostart') + return Promise.resolve(buildConfig({ general: { theme: 'system', layoutMode: 'floating', autoStart: true } })); + return Promise.reject(new Error(`unmocked: ${cmd}`)); + }); + + const openPromise = useSettingsStore.getState().open(); + await waitFor(() => { + expect(useSettingsStore.getState().isOpen).toBe(true); + }); + + await useSettingsStore.getState().setAutostart(true); + liveState.resolve(false); + await openPromise; + + expect(useSettingsStore.getState().config?.general?.autoStart).toBe(true); + }); }); diff --git a/src/features/settings/store.ts b/src/features/settings/store.ts index f845cf5..a3ab796 100644 --- a/src/features/settings/store.ts +++ b/src/features/settings/store.ts @@ -53,6 +53,15 @@ interface SettingsActions { setFontSize: (size: number) => void; /** Set editor font family (mono/sans): snapshot + persist+apply live. */ setFontFamily: (family: string) => void; + /** + * Enable or disable auto-start on login (Story 8.4). Delegates to the + * `set_autostart` command, which registers/unregisters the OS launch agent via + * `tauri-plugin-autostart` AND persists `[general] auto_start`. Not optimistic: + * awaits the backend, then adopts the returned config so the toggle reflects + * what was actually persisted; toasts on success, keeps the prior state and + * toasts on failure. Resolves `true` on success, `false` on error. + */ + setAutostart: (enabled: boolean) => Promise; /** * Set the global capture shortcut, conflict-checked. Unlike the live-apply * setters this is NOT optimistic: it awaits the backend, which registers the @@ -116,7 +125,22 @@ export const useSettingsStore = create((set, ge return false; } closeOtherOverlays('settings'); - set({ isOpen: true, config: result.data, bindings: bindingsFromConfig(result.data) }); + const loadedConfig = result.data; + set({ isOpen: true, config: loadedConfig, bindings: bindingsFromConfig(loadedConfig) }); + // Best-effort: reconcile the displayed auto-start toggle with the live OS + // state, which can drift from the persisted preference if changed outside the + // app. Failures are ignored — the toggle falls back to the persisted value. + try { + const os = await commands.getAutostart(); + if (os.status === 'ok') { + const cfg = get().config; + if (cfg === loadedConfig && cfg.general && (cfg.general.autoStart ?? false) !== os.data) { + set({ config: { ...cfg, general: { ...cfg.general, autoStart: os.data } } }); + } + } + } catch { + // ignore — best-effort reconciliation only + } return true; }, close: () => set({ isOpen: false }), @@ -169,6 +193,28 @@ export const useSettingsStore = create((set, ge } void applyFontFamily(family); }, + setAutostart: async (enabled) => { + let result; + try { + result = await commands.setAutostart(enabled); + } catch (error) { + console.error('setAutostart threw:', error); + useToastStore.getState().addToast('Couldn’t change auto-start on login.', 5000); + return false; + } + if (result.status === 'error') { + console.error('setAutostart failed:', result.error); + useToastStore.getState().addToast('Couldn’t change auto-start on login.', 5000); + return false; + } + // Adopt the backend's committed config so the toggle reflects the persisted + // (and OS-registered) state, never an optimistic guess. + set({ config: result.data }); + useToastStore + .getState() + .addToast(enabled ? 'Auto-start on login enabled' : 'Auto-start on login disabled'); + return true; + }, setGlobalShortcut: async (shortcut) => { let result; try { diff --git a/src/features/toast/components/Toaster.test.tsx b/src/features/toast/components/Toaster.test.tsx new file mode 100644 index 0000000..95130eb --- /dev/null +++ b/src/features/toast/components/Toaster.test.tsx @@ -0,0 +1,44 @@ +import { describe, it, expect, beforeEach, afterEach } from "vitest"; +import { render, screen, fireEvent } from "@testing-library/react"; +import { useToastStore } from "../store"; +import { Toaster } from "./Toaster"; + +describe("Toaster", () => { + beforeEach(() => { + useToastStore.getState().reset(); + }); + + afterEach(() => { + useToastStore.getState().reset(); + }); + + it("renders active toasts", () => { + useToastStore.getState().addToast("hello", 0); + render(); + expect(screen.getByText("hello")).toBeInTheDocument(); + }); + + it("dismisses a (persistent) toast when clicked", () => { + // A persistent toast (durationMs <= 0) never auto-dismisses; clicking is the + // only way to clear it. + useToastStore.getState().addToast("persistent notice", 0); + render(); + + const toast = screen.getByText("persistent notice"); + fireEvent.click(toast); + + expect(screen.queryByText("persistent notice")).not.toBeInTheDocument(); + expect(useToastStore.getState().toasts).toHaveLength(0); + }); + + it("renders toast cards as accessible dismiss buttons", () => { + useToastStore.getState().addToast("persistent notice", 0); + render(); + + expect( + screen.getByRole("button", { + name: "Dismiss notification: persistent notice", + }), + ).toBeInTheDocument(); + }); +}); diff --git a/src/features/toast/components/Toaster.tsx b/src/features/toast/components/Toaster.tsx index a739c80..5a61cd9 100644 --- a/src/features/toast/components/Toaster.tsx +++ b/src/features/toast/components/Toaster.tsx @@ -1,4 +1,4 @@ -import { useToastStore } from '../store'; +import { useToastStore } from "../store"; /** * Renders active toasts stacked at the bottom-right of the window. @@ -8,10 +8,13 @@ import { useToastStore } from '../store'; * visible. Individual toasts re-enable pointer events so only the visible * cards, not the full overlay, can ever intercept clicks. Uses * `aria-live="polite"` so screen readers announce new messages without - * interrupting. Auto-dismissal is owned by the store. + * interrupting. Auto-dismissal is owned by the store; clicking a toast dismisses + * it immediately, which is the only way to clear a persistent toast (one created + * with a non-positive duration, e.g. the hotkey-unavailable notice). */ export function Toaster() { const toasts = useToastStore((s) => s.toasts); + const dismissToast = useToastStore((s) => s.dismissToast); return (
{toasts.map((toast) => ( -
dismissToast(toast.id)} + aria-label={`Dismiss notification: ${toast.message}`} + title="Dismiss" style={{ - pointerEvents: 'auto', - backgroundColor: 'var(--bg-elevated)', - color: 'var(--text-primary)', - border: '1px solid var(--border-default)', - borderRadius: '6px', - padding: 'var(--space-2) var(--space-3)', - fontSize: '13px', - boxShadow: '0 4px 12px rgba(0, 0, 0, 0.3)', - maxWidth: '320px', + appearance: "none", + pointerEvents: "auto", + cursor: "pointer", + backgroundColor: "var(--bg-elevated)", + color: "var(--text-primary)", + border: "1px solid var(--border-default)", + borderRadius: "6px", + padding: "var(--space-2) var(--space-3)", + fontSize: "13px", + font: "inherit", + textAlign: "left", + boxShadow: "0 4px 12px rgba(0, 0, 0, 0.3)", + maxWidth: "320px", }} > {toast.message} -
+ ))}
); diff --git a/src/features/workspace/store.ts b/src/features/workspace/store.ts index 091641b..1687562 100644 --- a/src/features/workspace/store.ts +++ b/src/features/workspace/store.ts @@ -3,6 +3,7 @@ import { commands } from '../../generated/bindings'; import type { WorkspaceInfo, Note } from '../../generated/bindings'; import { useSearchStore } from '../search/store'; import { useTabStore } from '../tabs/store'; +import { withTimeout } from '../../lib/withTimeout'; /** Workspace state for tracking the active workspace context. */ interface WorkspaceState { @@ -91,13 +92,21 @@ export const useWorkspaceStore = create((set, }, trashNote: async (noteId) => { - const result = await commands.trashNote(noteId); - if (result.status === 'ok') { - useTabStore.getState().closeTabByNoteId(noteId); - await get().loadFilteredNotes(); - return result.data; - } else { - console.error('trashNote failed:', result.error); + try { + const result = await withTimeout(commands.trashNote(noteId), { + label: 'trash_note', + }); + if (result.status === 'ok') { + useTabStore.getState().closeTabByNoteId(noteId); + await get().loadFilteredNotes(); + return result.data; + } else { + console.error('trashNote failed:', result.error); + set({ notesError: 'Failed to move note to trash' }); + return null; + } + } catch (error) { + console.error('trashNote threw:', error); set({ notesError: 'Failed to move note to trash' }); return null; } @@ -107,12 +116,20 @@ export const useWorkspaceStore = create((set, set({ isLoadingNotes: true, notesError: null }); const { activeWorkspaceId, isAllWorkspaces } = get(); const workspaceId = isAllWorkspaces ? null : activeWorkspaceId; - const result = await commands.listNotes(workspaceId); - if (result.status === 'ok') { - set({ filteredNotes: result.data, isLoadingNotes: false, notesError: null }); - } else { - console.error('listNotes failed:', result.error); + try { + const result = await withTimeout(commands.listNotes(workspaceId), { + label: 'list_notes', + }); + if (result.status === 'ok') { + set({ filteredNotes: result.data, isLoadingNotes: false, notesError: null }); + } else { + console.error('listNotes failed:', result.error); + set({ isLoadingNotes: false, notesError: 'Failed to load notes \u2014 switch workspace to retry' }); + } + } catch (error) { + console.error('listNotes threw:', error); set({ isLoadingNotes: false, notesError: 'Failed to load notes \u2014 switch workspace to retry' }); + return; } }, diff --git a/src/generated/bindings.ts b/src/generated/bindings.ts index d6835cb..f79d634 100644 --- a/src/generated/bindings.ts +++ b/src/generated/bindings.ts @@ -33,6 +33,31 @@ export const commands = { * cannot clobber each other from stale snapshots. */ updateConfig: (partial: PartialAppConfig) => typedError(__TAURI_INVOKE("update_config", { partial })), + // Returns the persisted onboarding state (completion flag + session count). + getOnboardingState: () => typedError(__TAURI_INVOKE("get_onboarding_state")), + // Marks onboarding complete and persists it. Idempotent. + completeOnboarding: () => typedError(__TAURI_INVOKE("complete_onboarding")), + // Increments the persisted session counter and returns the new count. + incrementOnboardingSession: () => typedError(__TAURI_INVOKE("increment_onboarding_session")), + /** + * Whether the OS has granted the accessibility permission the global hotkey + * depends on. Always `Ok(true)` off macOS (no such gate). + */ + checkAccessibilityPermission: () => typedError(__TAURI_INVOKE("check_accessibility_permission")), + /** + * Open the OS settings pane where the user grants accessibility permission. + * No-op off macOS. + */ + openAccessibilitySettings: () => typedError(__TAURI_INVOKE("open_accessibility_settings")), + // Enable/disable auto-start via the plugin, persist atomically, and return committed config. + setAutostart: (enabled: boolean) => typedError(__TAURI_INVOKE("set_autostart", { enabled })), + /** + * Whether auto-start on login is currently registered at the OS level. + * Reports the live platform state via the autostart plugin (the source of truth + * for the *active* registration), letting the UI reconcile its toggle with the + * real OS state. Off desktop there is no launch agent, so it reports `false`. + */ + getAutostart: () => typedError(__TAURI_INVOKE("get_autostart")), // Hides the calling window (dismiss without destroy). dismissWindow: () => typedError(__TAURI_INVOKE("dismiss_window")), /** @@ -79,10 +104,19 @@ export const commands = { * export service. */ exportJson: (filePath: string) => typedError(__TAURI_INVOKE("export_json", { filePath })), + /** + * Return the global-shortcut backend status for the current session. + * + * Reads the value recorded during startup hotkey detection. A poisoned lock is + * recovered by cloning the inner value — the status is plain data with no + * transactional state to repair. + */ + getHotkeyStatus: () => __TAURI_INVOKE("get_hotkey_status"), }; /** Events */ export const events = { + hotkeyPressed: makeEvent("hotkey-pressed"), noteCreated: makeEvent("note-created"), }; @@ -119,14 +153,19 @@ export type EditorConfig = { /** * General application settings. - * * `theme` is one of `system` (the default — follow the OS `prefers-color-scheme` * until the user picks a theme), `dark`, or `light`. A saved manual `dark`/`light` * preference overrides the OS setting on restart. + * `auto_start` (serialized `[general] autoStart`) is the persisted auto-start-on-login + * preference (Story 8.4 / FR41–FR43). It defaults to `false` and tolerates a missing + * key on older config files via serde. The OS launch agent is managed by + * `tauri-plugin-autostart`; this field is the single source of truth the app + * reconciles the OS registration to on every startup. */ export type GeneralConfig = { theme: Theme, layoutMode: string, + autoStart?: boolean, }; // Hotkey bindings. @@ -134,6 +173,34 @@ export type HotkeyConfig = { globalShortcut: string, }; +/** + * The `hotkey-pressed` event — emitted whenever the registered global capture + * shortcut fires. + * + * First-run onboarding (Story 8.1) dismisses its overlay when the user presses + * the hotkey, but the OS-level shortcut hides the window without reloading the + * webview, and a registered global shortcut does not reliably deliver a keydown + * to the focused page across platforms. The shortcut handler emits this typed + * event; the visible overlay listens via the generated `events.hotkeyPressed` + * binding and completes onboarding. It is a marker event with no payload. + */ +export type HotkeyPressed = null; + +/** + * Availability of the global-shortcut backend for the current session. + * + * Wire shape (camelCase): `{ "available": false, "reason": "" }`. + */ +export type HotkeyStatus = { + // `true` when a usable global-shortcut backend was found at startup. + available: boolean, + /** + * Human-readable reason the backend is unavailable, when `available` is + * `false`. `None` when the hotkey is available. + */ + reason: string | null, +}; + export type Note = { id: number, title: string, @@ -166,6 +233,26 @@ export type NoteCreatedData = { export type NoteyError = { type: "Database" } | { type: "NotFound" } | { type: "Workspace" } | { type: "Io" } | { type: "Validation"; message: string } | { type: "Config"; message: string }; +/** + * Persisted first-run onboarding state. + * + * Serialized to `onboarding.toml`. `complete` gates the one-time onboarding + * overlay; `sessions_seen` counts app launches so the early command hint can + * retire itself after [`COMMAND_HINT_SESSION_LIMIT`] sessions. + */ +export type OnboardingState = { + /** + * `true` once the user has dismissed the onboarding overlay (by pressing the + * hotkey or Esc). The overlay is never shown again once this is set. + */ + complete?: boolean, + /** + * How many sessions the user has started. Drives the progressive + * command-palette hint in the status bar. + */ + sessionsSeen?: number, +}; + // Partial config for updates — all fields optional. export type PartialAppConfig = { general: PartialGeneralConfig | null, diff --git a/src/lib/withTimeout.test.ts b/src/lib/withTimeout.test.ts new file mode 100644 index 0000000..e99725c --- /dev/null +++ b/src/lib/withTimeout.test.ts @@ -0,0 +1,110 @@ +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import { + withTimeout, + IpcTimeoutError, + IPC_TIMEOUT_MS, +} from './withTimeout'; + +/** A promise whose settlement the test controls. */ +function deferred() { + let resolve!: (value: T) => void; + let reject!: (reason?: unknown) => void; + const promise = new Promise((res, rej) => { + resolve = res; + reject = rej; + }); + return { promise, resolve, reject }; +} + +describe('withTimeout', () => { + beforeEach(() => { + vi.useFakeTimers(); + }); + + afterEach(() => { + vi.useRealTimers(); + }); + + it('resolves with the operation value when it settles before the timeout', async () => { + const d = deferred(); + const wrapped = withTimeout(d.promise); + + d.resolve(42); + await expect(wrapped).resolves.toBe(42); + }); + + it('rejects with the operation reason when it rejects before the timeout', async () => { + const d = deferred(); + const wrapped = withTimeout(d.promise); + const boom = new Error('invoke failed'); + + d.reject(boom); + await expect(wrapped).rejects.toBe(boom); + }); + + it('rejects with IpcTimeoutError when the operation never settles', async () => { + const d = deferred(); + const wrapped = withTimeout(d.promise, { label: 'create_note' }); + // Surface the eventual rejection before advancing timers so the rejection + // is observed (avoids an unhandled-rejection warning under fake timers). + const assertion = expect(wrapped).rejects.toBeInstanceOf(IpcTimeoutError); + + await vi.advanceTimersByTimeAsync(IPC_TIMEOUT_MS); + await assertion; + // d.promise is intentionally left pending — it models a hung invoke. + }); + + it('clears the timer once the operation resolves (no leaked timeout)', async () => { + const d = deferred(); + const wrapped = withTimeout(d.promise); + + d.resolve(1); + await wrapped; + + expect(vi.getTimerCount()).toBe(0); + }); + + it('does not double-settle or throw when the operation settles after the timeout', async () => { + const d = deferred(); + const wrapped = withTimeout(d.promise, { timeoutMs: 1000 }); + const assertion = expect(wrapped).rejects.toBeInstanceOf(IpcTimeoutError); + + await vi.advanceTimersByTimeAsync(1000); + await assertion; + + // A late settlement of the (already-lost) operation must be a harmless + // no-op: no unhandled rejection, no second settlement of `wrapped`. + d.reject(new Error('late failure')); + await vi.advanceTimersByTimeAsync(0); + expect(vi.getTimerCount()).toBe(0); + }); + + it('honors a custom timeoutMs', async () => { + const d = deferred(); + const wrapped = withTimeout(d.promise, { timeoutMs: 250 }); + const assertion = expect(wrapped).rejects.toBeInstanceOf(IpcTimeoutError); + + // Not yet elapsed at the default bound's earlier point... + await vi.advanceTimersByTimeAsync(249); + expect(vi.getTimerCount()).toBe(1); + + await vi.advanceTimersByTimeAsync(1); + await assertion; + }); + + it('includes the label and bound in the timeout message', async () => { + const d = deferred(); + const wrapped = withTimeout(d.promise, { label: 'export_json', timeoutMs: 500 }); + const assertion = wrapped.then( + () => { + throw new Error('expected a timeout rejection'); + }, + (e: unknown) => e as Error, + ); + + await vi.advanceTimersByTimeAsync(500); + const err = await assertion; + expect(err.message).toContain('export_json'); + expect(err.message).toContain('500'); + }); +}); diff --git a/src/lib/withTimeout.ts b/src/lib/withTimeout.ts new file mode 100644 index 0000000..b2748ff --- /dev/null +++ b/src/lib/withTimeout.ts @@ -0,0 +1,86 @@ +/** + * Default bound on a single Tauri IPC round-trip, mirroring the CLI's 5s + * connect/round-trip timeout (Story 6.7). Notey commands are quick local-SQLite + * operations, so a round-trip that has not settled in 5s is treated as a hung + * IPC promise rather than slow work. + */ +export const IPC_TIMEOUT_MS = 5000; + +/** + * Generous bound for the long-running export commands (`export_markdown` / + * `export_json`), which write one file per note and can legitimately run for + * many seconds on a large workspace. The bound is not about latency — it exists + * only so a genuinely hung export promise still settles and releases its + * `singleflight` key instead of disabling export until reload. + */ +export const EXPORT_IPC_TIMEOUT_MS = 60_000; + +/** + * Rejection raised by {@link withTimeout} when the wrapped operation does not + * settle within its bound. Distinct from any backend `NoteyError` so callers' + * existing error paths log it as just another invoke failure. + */ +export class IpcTimeoutError extends Error { + constructor(label: string, timeoutMs: number) { + super(`IPC operation "${label}" timed out after ${timeoutMs}ms`); + this.name = 'IpcTimeoutError'; + } +} + +/** + * Race a Tauri IPC promise against a timeout so it always settles. + * + * The shared `singleflight` helper only releases an in-flight key once its + * wrapped operation settles; a Tauri invoke promise that never settles would + * therefore wedge that key forever (see DW-90). Wrapping the invoke with + * `withTimeout` guarantees the operation settles — either with the invoke's own + * result/rejection, or with an {@link IpcTimeoutError} once the bound elapses — + * so the `singleflight` `finally` always runs. `singleflight` itself stays + * timer-free. + * + * This is a frontend-side bound: it stops the UI awaiting a dead promise, but it + * cannot cancel the backend command, which may still complete. The timer is + * always cleared once `operation` settles, win or lose the race, so no timer + * leaks and a late settlement after the timeout neither double-settles the + * returned promise nor surfaces an unhandled rejection. + * + * Do NOT wrap native dialog promises (`save`/`open`): those legitimately wait on + * the user and must not be bounded. + * + * @param operation The IPC promise to bound (typically a generated `commands.*` call). + * @param opts.timeoutMs Bound in milliseconds; defaults to {@link IPC_TIMEOUT_MS}. + * @param opts.label Human-readable name for the operation, used in the timeout message. + * @returns A promise that settles with `operation`'s result, or rejects with + * {@link IpcTimeoutError} if the bound elapses first. + */ +export function withTimeout( + operation: Promise, + opts?: { timeoutMs?: number; label?: string }, +): Promise { + const timeoutMs = opts?.timeoutMs ?? IPC_TIMEOUT_MS; + const label = opts?.label ?? 'ipc'; + + return new Promise((resolve, reject) => { + const timer = setTimeout(() => { + reject(new IpcTimeoutError(label, timeoutMs)); + }, timeoutMs); + + // Attaching handlers here (rather than racing a separate promise) means a + // rejection from `operation` is always observed — never an unhandled + // rejection — even if the timeout already won the race. The timer is cleared + // synchronously with settlement, so it is gone the moment the returned + // promise settles. Once the outer promise has settled, these resolve/reject + // calls are inert no-ops, so a late settlement neither double-settles nor + // throws. + operation.then( + (value) => { + clearTimeout(timer); + resolve(value); + }, + (reason) => { + clearTimeout(timer); + reject(reason); + }, + ); + }); +} diff --git a/src/test-utils/factories.ts b/src/test-utils/factories.ts index 63fec26..97a4d95 100644 --- a/src/test-utils/factories.ts +++ b/src/test-utils/factories.ts @@ -31,7 +31,7 @@ export function buildWorkspaceInfo(overrides: Partial = {}): Work /** Build an AppConfig with sensible defaults. Override nested sections via the partial. */ export function buildConfig(overrides: Partial = {}): AppConfig { return { - general: { theme: 'system', layoutMode: 'floating' }, + general: { theme: 'system', layoutMode: 'floating', autoStart: false }, editor: { fontSize: 14, fontFamily: 'mono' }, hotkey: { globalShortcut: 'Ctrl+Shift+N' }, shortcuts: {