Repository navigation
fix: release readiness for the first public release - #2
Merged
Merged
Conversation
CI's dtolnay/rust-toolchain@stable now installs Rust 1.100.0, whose clippy extends needless_bool to an `if` guard that returns a bool literal and is followed by the opposite literal. The retain closure in purge_legacy_builtin_seeds hit it and failed the -D warnings gate. Return the negated condition instead: same result, same short-circuit order. Cargo 1.100 also reports two dependencies nothing uses (cargo::unused_dependencies): fleetify-app's dotenvy build-dependency, a leftover of compile-time PostHog key loading that runtime resolution replaced (build.rs only calls tauri_build::build()), and serde in fleetify-core. Drop both so the gate output is clean. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
A release build signs in against production fleetify.dev, but the embedded backend validated the resulting tokens against a local identity provider (http://localhost:3001) and audience (http://127.0.0.1:8765) unless FLEETIFY_ISSUER and FLEETIFY_AUDIENCE happened to be set. The shell and the backend each resolved these values on their own and only the shell pinned production, so the backend would reject the tokens from every real sign-in. Resolve the issuer origin and the API resource (the token audience) once, in fleetify_core::endpoints, and use it from the shell's OAuth client, the backend's AuthConfig and the telemetry WebSocket client. Release builds return the production values and ignore the environment. Debug builds keep reading FLEETIFY_ISSUER and FLEETIFY_RESOURCE, then FLEETIFY_AUDIENCE, with the same local defaults; the dev scripts set both of the latter to the same value. In debug builds the telemetry WebSocket client now falls back to the local IdP origin instead of production when FLEETIFY_ISSUER is unset, matching the shell it takes its token from. Its URL test now passes base URLs directly instead of setting FLEETIFY_ISSUER, which release builds ignore. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
The embedded backend called dotenvy::dotenv() on every start, and dotenvy takes the first .env it finds in the working directory or any of its ancestors. Launching a release build from a terminal inside some project therefore let that project's .env configure Fleetify: the sessions database (FLEET_DB_URL), the data directory (FLEETIFY_HOME), the PostHog and Not Diamond keys, and anything else read from the process environment after startup. Only debug builds load .env now. The call site asks should_load_dotenv(!cfg!(debug_assertions)), the same release check the auth endpoints use, and a unit test pins the rule. Debug builds keep today's behaviour, so the single-file dev config under npm run dev:tauri still works. .env.example now states that only debug builds read the file and marks NOTDIAMOND_API_KEY as development-only. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
Every crate built keyring with its linux-native store, the kernel keyutils keyring, which keyring's own documentation describes as in-memory and not persistent across reboots. On Linux the OIDC refresh token, provider API keys and the other stored secrets were gone after every restart of the machine, so the user had to sign in and re-enter their keys. Build keyring with linux-native-sync-persistent and crypto-rust. That makes the Secret Service (GNOME Keyring, KWallet, ...) the default Linux store and encrypts secrets on the D-Bus wire. fleetify-backend, src-tauri and fleet-wipe now declare the same feature set. keyring scopes its Linux dependencies to Linux targets, so Windows and macOS builds resolve exactly as before, except that fleet-wipe built on its own on macOS now gets the Keychain store instead of the mock one. Building on Linux needs libdbus-1-dev and pkg-config, which the Tauri shell already required through tao. A fleetify-backend test fails to compile on Linux if the persistent store is dropped from the feature set again. Entries written by earlier builds exist only in the kernel keyring and are not migrated; they have to be entered once more. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
The app now keeps its Linux credentials (OIDC refresh token, GitHub link, voice, provider and router keys) in the Secret Service, but the reset helper still swept only the kernel keyring. wipe.mjs's secret-tool pass could not help either: `secret-tool search --all` without an attribute pair is malformed, and secret-tool is often not installed. After `npm run wipe` on Linux the app stayed signed in and kept its API keys. fleet-wipe now deletes every Secret Service item keyring created whose service is Fleetify or Fleetify-*. It searches for application = rust-keyring, the value keyring's code sets (its 3.6.3 module docs say rust-keyring-client, which matches nothing). It prints only service and username, never reads a secret, and still sweeps the kernel keyring for entries that older builds left there. A real run first unlocks a locked default collection. GNOME Keyring shows a locked item only with hashed attributes and refuses to delete it, so after an auto-login boot the sweep would otherwise remove nothing. When the sweep fails, fleet-wipe exits 1, so wipe.mjs reports the failure instead of printing "cleared". wipe.mjs drops the secret-tool pass, and its header now says where Linux credentials live. The new Linux-only test stores throwaway items through keyring, as the app does, and fails when no Secret Service is reachable. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
Linux now keeps the refresh token in the Secret Service. When there is none (no GNOME Keyring or KWallet) or the user dismisses the unlock prompt, the save fails, and the shell discarded that error: the user looked signed in but started signed out after every restart, with nothing saying why. The shell now logs the failure and sends the renderer a keychain-unavailable auth event, after sign-in and after each token refresh. Sign-in itself still succeeds, because the access token is cached in the process and the current session keeps working. The renderer shows a dismissible banner at the top of the main shell that says the next launch will ask for sign-in again and how to fix it on Linux. A sign-out drops the banner, since it was about that sign-in. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
The release build job will run it over dist/ and the bundle outputs so that no private API key or token can ship inside an installer. It prints `<file>: <rule>` for each finding and never the matched value, so the CI log cannot become the leak. Exit 0 means clean and 1 means findings. Exit 2 means the scan could not be completed (no path, a missing or empty path, a read error), so a job pointed at the wrong directory fails instead of passing as clean. The test fixtures are assembled at runtime from runs of "x", so no token-shaped literal lands in the public repository. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
Commits the app makes carry a Fleetify co-author trailer, and PRs it opens through gh carry a "Created with Fleetify" footer, with no way to opt out. Settings > General > Attribution now has a switch, on by default, that saves gitAttribution to fleet.config.json. The Create PR command reads it on every call; when it is off, neither path adds the trailer and the gh path adds no footer. An existing Fleetify co-author line, whatever its casing or address, is never doubled. The General cards now merge each change into the config as it is when they save. config_set replaces the whole file, so a card that merged into the copy it read at mount undid whatever another card had saved since: turning attribution off and then flipping any other General switch silently turned attribution back on. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
…and logs String::truncate(n) and &s[..n] panic when byte n falls inside a multi-byte character. Fleetify is Türkiye-first: Turkish letters are two bytes and emoji four, so an AI-written Turkish commit subject over 72 bytes crashed "generate commit message" and "Create PR". fleetify_core::text adds truncate_chars, for limits stated in characters such as the 72-character subject, and prefix_within_bytes, for byte budgets, which backs off to the previous character boundary. The byte cuts found on user-, model- or provider-supplied text now use them: the commit subject, the commit, PR and review diff budgets, the claude-code stderr log line (which still reports the bytes it dropped), the README budget in the agentic system prompt, and the error bodies of the OpenAI, OpenAI-compatible and Perplexity bridges. The reveng sidecar's endpoint context window backs off the same way, with str::floor_char_boundary. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
App.tsx keeps AppShell mounted under display: none while Settings or Library is open, and the shortcut handler ignored every key while the shell was hidden, so Cmd/Ctrl+Shift+A could not stop runaway agents from those pages. A binding can now be marked worksWhileParked; only abort-all is, because it does not act on the hidden UI. Escape and the other bindings still do nothing while the shell is parked. The handler now finds the matching binding before it checks whether the shell is on screen, so keystrokes that no binding handles, which is nearly all typing, no longer walk the DOM with getComputedStyle. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
…vity details The Fleetify-cloud channel feeds the fleetify.dev dashboard over the account-authenticated WebSocket. Its Settings switch wrote a flag that no code read, so the channel was always on, while the published privacy policy promises that session data is sent only after an opt-in. The backend now has a runtime gate. It stays closed until the shell restores the saved choice at startup, and the new telemetry_set_cloud_enabled command flips it live. While it is closed nothing is queued, and the WS loop holds no bearer, ticket or socket. Every close purges the outbox, so turning sync off leaves nothing to send later. The choice is stored as telemetry.cloud_sync_enabled. An explicit legacy telemetryEnabled: false still counts as an opt-out; everyone else gets CLOUD_SYNC_DEFAULT, which is off. Activity summaries are no longer sent. They carried agent shell commands, file paths, URLs, search queries and sub-agent prompts, and the dashboard never shows them. Project paths are cut to the folder name, because the full path carries the OS user name. The send path applies the same view to rows that older builds queued. PostHog keeps its own consent gate and still gets the original payload, which its mapper already hashes and trims. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
discover_assets scans fetched HTML for src=, data-src= and href= values. When the byte after the = was not a quote, the scan resumed one byte later. On a page with <a href=ürünler.html> that byte sits inside a letter, and the next slice panicked. Windows-1254 pages hit it too: fetch_url decodes them lossily, and the U+FFFD that replaces 0xFC is 3 bytes long. Tool calls run inline on a current-thread runtime, so the panic killed the sidecar and the agent lost every reveng tool for the rest of the session. The scan now resumes right after the =, which is always a character boundary. It lives in a pure function, so the crash is testable without the network. Unquoted values are still skipped, and quoted values come back as before, in document order. The one output that changes is the degenerate src=src="a.png": the inner quoted value is now found, as it already was for src=xsrc="a.png". Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
parse_device_code found "code:" in a Unicode-lowercased copy of the line, then sliced the original line at that offset. Unicode lowercasing can change byte lengths (İ grows from 2 bytes to 3), so after such text the offset pointed too far. The device code was missed, or the slice landed inside a letter or past the end of the line and the panic failed the GitHub sign-in. ASCII lowercasing keeps every byte offset, which is all a search for "code:" needs. logging.rs already does the same. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
… on macOS Mod+Shift+A is the emergency stop for every running agent, and it only matched key "A". With Caps Lock on, Shift types a lowercase letter on Windows and Linux, so the key arrives as "a" (WebKitGTK reports exactly that), and macOS may leave Shift out of key while Cmd is held. Either way nothing stopped. abort-all and toggle-sidebar now compare the key case-insensitively, like the other letter bindings. They still compare key, not code, so each shortcut stays on the letter its label names. Mod+Shift+. could never fire on Windows or Linux: key includes Shift, so the chord reports ">" on a US layout and ":" on German, never ".". It now also accepts ">" and the physical Period key, except where that key types a letter (V on Dvorak), so Ctrl+Shift+V keeps pasting there. Turkish Q, where "." sits on the Slash key, still misses it. abort-all also stops agents whose chat is still streaming while the app store does not mark them running, because the Fleet panel shows those as running too. Each agent is stopped once, and the staff session never. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
… opt-out saves Builds before the consent gate queued every event, unminimised, whether or not the user had opted in. The previous commit relied on the startup restore of a closed gate to purge those rows. Nothing orders that restore after the backend opens its outbox, so the purge could be skipped. An opt-in never purges, so the WS loop would then replay the rows. The outbox now records a data version in PRAGMA user_version. When it opens a version-0 database, it drops every row before the pool is published, so no reader can see them. Rows queued after that survive later starts. Turning sync off saved the choice but discarded the result and always answered ok. When the save failed, the gate closed for the session, but the old setting reopened it at the next launch without telling the user. The command still applies the change for the session; when the save fails it now also logs a warning and answers ok: false, with a message the Settings page can show. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
The Secret Service sweep printed "service=<service> username=<username>" for every item, and for some services the username is the user's Fleetify account ID. CodeQL flagged those three lines as cleartext logging of sensitive information. Nobody needs the ID in wipe output: the service alone tells the user what was or would be removed. The lines now name each item by its service, and the sweep stops reading the username. The kernel keyring sweep printed whole key descriptions, keyring-rs:<account>@<service>, which hold the same ID. It now prints only the service half. The macOS/Windows backstop printed refresh_token@Fleetify. That account is a fixed name that identifies nobody, but it goes too, so no output line names an account. The Secret Service formatter is named describe_ss_item rather than describe_secret_service_item: CodeQL treats the result of any function whose name contains "secret" as sensitive, and would flag every line that printed it. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
… Ctrl+/ on AZERTY The previous commit let Mod+Shift+. match the physical Period key whenever that key did not type a letter. On French and Belgian AZERTY, "/" is Shift on that key, so Ctrl+/ matched too: toggling a comment in the Files editor (CodeMirror's Mod-/) also collapsed the right panel the editor sits in. On Turkish Q the shortcut did nothing. There "." sits on the Slash key and Shift turns it into ":". Turkish Q is the most common layout in Turkey, so the chord shown in Help failed for most Turkish users. Beyond "." and ">", the matcher now accepts only ":", from the Period key (German, Nordic, Spanish, Italian, Swiss, Czech, Hungarian, Turkish F) or the Slash key (Turkish Q, Latvian modern). It can never match a letter, so Ctrl+Shift+V still pastes on Dvorak. Brazilian ABNT2's ;: key sends the same event; nothing else binds that chord. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
… failed privacy saves A fleet.config.json that didn't parse, after a hand edit with one stray comma for instance, loaded as an empty object. Every setter reads, merges and writes the whole file, so the next save replaced it with that one setting and silently dropped every other. Now a file that reads but isn't a JSON object, including one that isn't UTF-8, is moved aside to fleet.config.json.corrupt-<unix-ms>, or copied there when it can't be moved, and the warning names the backup. Turning product analytics off saved the choice but discarded the result and always answered ok. If the save failed, the old setting turned PostHog back on at the next launch without telling the user. The command now answers ok: false with a message, like the cloud sync switch, and still applies the change for the session. A re-opt-in also keeps the first opt-in time instead of stamping a new one. config_set reports failed saves the same way. The telemetry section was rewritten from the parsed struct. One malformed field sent the struct to its defaults, so a product analytics toggle dropped the saved cloud sync choice. The section is now merged field by field, and keys the struct can't read survive. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
…alls Icon URLs come from third-party marketplace manifests, so the backend must not be steerable at the user's own machine or network. The old check resolved the host, vetted the answer, and then let reqwest resolve the name again to connect. A name with a short TTL could answer with a public address for the check and with 127.0.0.1 for the connection (DNS rebinding). The vetting now happens inside the icon client's DNS resolver, and the connector dials only the addresses it returns. The client also ignores system proxies, because a proxy resolves the name itself and would dial whatever it found. The address check missed ranges that are just as unreachable from the public internet: 0.0.0.0/8, 192.0.0.0/24, 198.18.0.0/15, 240.0.0.0/4 and the deprecated fec0::/10. It also missed IPv6 forms that carry an IPv4 address (IPv4-compatible, 6to4, NAT64). Those are now judged by the IPv4 address inside them, as IPv4-mapped ones already were. A dead or slow icon host made every catalog load wait out the full 8-second fetch timeout again, because all icons are awaited together. A URL that fails is now skipped for ten minutes, and its expired cached copy, if there is one, is served meanwhile. DNS lookups give up after three seconds. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
The backup renamed whatever sat at the config path, not the bytes the load had parsed. A load that read the corrupt file could then move away a valid file saved meanwhile, or a complete edit it caught half written, so the live config read as empty again. Backups were also named by the millisecond, and rename and copy replace an existing file, so two loads racing on the same file could overwrite the backup that held the original settings. The load now writes the bytes it read to a new file named by their content hash, created only if it doesn't exist, and never touches the live file. Loading the same corrupt bytes again finds the copy already kept and logs nothing. Changed bytes get their own copy. A failed write removes its partial copy, so a later load doesn't take it for a kept one. A config saved with a UTF-8 byte order mark, as some Windows editors write, now loads instead of counting as corrupt. A corrupt one is kept with its mark. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
…arked dialogs Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
… in NOTICE Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
The inactive-session sweep kept only the sessions a chat view shows: the active or staff session and the split panes. A Workflows run detail shows a session that no chat view has on screen, and it fetches that transcript only once per session id. So the sweep emptied it about 20 seconds after it opened, and nothing loaded it again. Surfaces outside chat-view can now pin the sessions they show. Pins are reference-counted, and the sweep keeps the union of the visible and the pinned sessions. The run detail pins its run's session. The Mission Status strip and the Live Pulse feed pin every session whose messages they read. Each pin is released on unmount and whenever the ids change. Neither dashboard widget is mounted today. Their pins keep them correct if one comes back. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
…scape Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
… in memory Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
…y on click A plugin's README and CHANGELOG are third-party markdown, and both renderers loaded any https: image straight into the WebView: a tracking pixel, or a request to a host on the user's own network, with no backend check in between. Both now use one img component. data: images render (react-markdown's default URL check used to drop them, so a custom urlTransform keeps data:image sources and leaves every other URL to the default). https: images from GitHub's image hosts and img.shields.io render; any other https: host shows a "Load image from <host>" button and loads only after a click. Other schemes and relative paths show their alt text. Images that load send no referrer. OverviewBody is exported so the README renderer can be tested on its own. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
…never from a text field The card handlers accepted only metaKey, while their labels say Ctrl+Enter / Ctrl+Shift+Enter on Windows and Linux, so the shortcuts were dead there. Separately, on macOS, ⌘↵ in the Fleet dispatch reply box sent the reply and also approved a pending card: the field rule only covered fields outside the chat, and the reply box's preventDefault wasn't honoured. First, the cards now leave Mod+Enter and Mod+Shift+Enter alone when another handler already acted on them (defaultPrevented) or when they were typed in any editable field, inside or outside the chat. While a card waits the composer is locked and the card has no fields, so a focused field always belongs to something else. Then they accept the platform's Mod, from the same getPlatform() the labels use: metaKey on macOS, ctrlKey elsewhere. Both handlers share cardShortcut and cardShortcutOwnedElsewhere. Escape is unchanged. Tests that pressed ⌘↵ on the Linux happy-dom reports now press Ctrl, and assert that platform, so they keep testing what they claim. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
The shell's startup wait polled /health, but the backend only serves
/healthz (in release builds /health fell through to the static files and
404'd). Every launch therefore sat out the whole 4 s timeout before the
providers warm-up ran.
The wait now polls the backend's own route, exported as
fleetify_backend::HEALTH_PATH so the two can't drift again, and counts
the backend up only when it answers 2xx with {"status":"ok"}, so a 200
from something else on the port doesn't count. Each poll has a 500 ms
timeout, so a port that accepts and never answers can't hang the
warm-up. The 20 × 200 ms limit stays as the fallback, and running out
of it is now logged. The loop moved to shell::backend_ready so it can be
tested against a local server.
Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
…c back on
A settings file that is there but can't be read or parsed loads as {},
the same as a fresh install, so dashboard sync fell back to its default.
With the default about to become on, a corrupt file would turn an
earlier opt-out back on.
The shell now tells the two apart. load_config_with_status reports
Missing, Ok, Corrupt or Unreadable; load_config_from keeps its behaviour
for every other caller. startup_cloud_decision, called once at the top
of setup, keeps sync off for a Corrupt or Unreadable file and saves an
explicit opt-out through persist_cloud_choice, so later launches stay
off until the user turns sync back on. If that save fails, sync still
stays off for this launch. The warning names the condition, never the
file's content or its folder. A missing file still gets the default.
The decision runs before the window is built and before the key
migration starts, so it lands before any other read or write of the
file, the renderer's included: no command runs until setup returns.
The early open follows it, and the final restore closes the gate when
the launch decision kept sync off or the file is broken by then
(saved_cloud_choice, which saves nothing). cloud_sync_from stays pure,
and telemetry_get_config still reports the live gate.
Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
The fleetify.dev dashboard is the core of the account-based product, and with sync off by default most users would never see it populated. What sync sends is already minimised: no shell commands, code, file contents or full paths, and only folder names, with the home folder sent as ~. CLOUD_SYNC_DEFAULT is now true. cloud_sync_from keeps its precedence: a saved choice wins, then the old switch's opt-out, then the default. A missing settings file gets the default; one that is there but broken keeps sync off (previous commit). Onboarding's dashboard step becomes a disclosure. It says what sync sends and that it is on, with Keep it on and Turn it off; either button saves the choice explicitly, and only a choice the backend took is acknowledged. Keeping sync on isn't an opt-in, so it stamps no opt-in time. The privacy card now says On by default, and ANALYTICS.md and CLAUDE.md describe the default, the switch and the fail-closed rule. Product analytics (PostHog) stays opt-in and is unchanged. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
An isolated launch of the release AppImage ended on the engine's error page, "Could not connect to 127.0.0.1: Connection refused". The main window loaded the embedded backend's URL as soon as it was built, the backend bound two seconds later (its bind waits on the keychain), and WebKit never retries a first navigation that failed. The reveal poll only decided when to show the window, so it showed the error page. The window now starts, hidden, on a placeholder page Tauri serves itself, on a scheme that answers the main window only. The existing poll of the webview URL decides when the window loads the app, and the window is shown once the app page has finished loading, with a 5 s fallback so a missed page-load event can never keep it hidden. Past the old 15 s cap without an answer, the window shows the placeholder, "Starting Fleetify…", in the app's light or dark colours, and the poll goes on with no cap until the app answers. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
Release builds load the app from http://127.0.0.1:$FLEETIFY_BACKEND_PORT and debug builds from http://localhost:$VITE_PORT, but capabilities/default.json allows IPC only from the default ports, 8765 and 3000. On any other port the engine denied every IPC call, and a launch with FLEETIFY_BACKEND_PORT=8899 stayed on a blank window. When the app's origin is not one of those, setup now adds a capability for that exact origin and the main window, with the permissions default.json grants. default.json stays as it is; tests fail if its origins or permissions drift from what the runtime capability mirrors. The window URL and the capability origin come from one function and from ports parsed once, so they cannot differ. An invalid VITE_PORT falls back to 3000, as vite.config.ts does. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
… on new installs With sync on by default, a new install opened the gate at its first launch. Heartbeats then queued, and after sign-in they reached the cloud and linked the device to the account, all before onboarding's dashboard step, which comes after the provider, GitHub and theme steps. startup_cloud_decision now keeps a new install closed. With no settings file, or one that holds neither a saved choice nor onboardingComplete: true, sync stays off and nothing is written; the onboarding buttons open the gate. Past either, the saved choice decides, so users who finished onboarding keep the default, and an explicit opt-out still wins. An unreadable file is now moved aside whole, as fleet.config.json.unreadable-<ms>, before the opt-out takes its place: a rename needs only write access to the folder and keeps the bytes, owner and mode. A folder is never moved and an earlier aside is never replaced. If the opt-out can't be saved, the file is put back, so the next launch doesn't take it for a new install. ANALYTICS.md says when sync starts on a new installation, and narrows the fail-closed claim to a settings file that exists but can't be read or parsed. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
ConsentWidget filled the yes button and left no as a quiet secondary one. The same widget asks both privacy questions, so dashboard sync's Keep it on and product analytics' Sure, help out were each the highlighted choice: the one that shares data. Both buttons now share one style, the former secondary one, so neither choice is nudged. Labels, order, behaviour and accessible names are unchanged. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
Release builds load the UI from http://127.0.0.1:<port>, which Tauri treats as a remote origin, and Tauri refuses an app command from a remote origin unless the ACL allows it. App commands get permissions only from an app ACL manifest, and the app had none, so the release UI could reach none of its commands: not sign-in, config, telemetry or the window controls. Debug builds load Vite on devUrl, a local origin, so development never showed it. build.rs now declares the manifest from one list of every command lib.rs registers (src/app_commands.rs). The app-commands permission set holds all of them, and capabilities/default.json and the runtime capability for a configured port both grant it. Both now apply to the main webview instead of the main window. A window scope also matches the browser panel, a child webview in that window, so a page there on one of the app's origins got the core permissions, and with the manifest it would have got every app command too. In debug builds a page from the dev server's origin already could call them. The panel now gets no command at all. Tests fail when the list and generate_handler! differ, when the set and the list differ, or when default.json and the runtime capability disagree on permissions or scope. They also resolve the compiled ACL: the main webview gets every command from each app origin, the browser panel none. tauri-build rewrites its per-command permissions on every build, so they are not committed. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
… can't start Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
capabilities/default.json allowed two fixed remote origins, http://localhost:3000 and http://127.0.0.1:8765, and with the app manifest it gave them every app command: pty_spawn, fs_read_file, auth_get_access_token, git_push. A release build never loads the first, and the second isn't the app when the backend runs on another port. The main webview has no navigation guard, so a page it reached on either (a README link to a dev server, a dropped URL) got the whole app. default.json now covers local origins only: devUrl in dev mode and the app's own schemes. Setup grants the same permissions, for the main webview, to exactly the origin the window loads the app from: always in release, the backend on http://127.0.0.1:<port>, and in debug only when Vite isn't the local devUrl. Whether an origin is local follows Tauri's own rule: devUrl in dev mode, a frontendDist URL otherwise. A failure to add the grant is logged as an error. build.rs now checks the command list against generate_handler! and fails the build on a mismatch, so a command registered without a manifest entry fails CI's hard gates, not only a test that can't block a merge. The unit test runs the same check. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
…ng the app Markdown the app didn't write rendered plain links: a project's README in the file preview, an agent's plan, the AI code review and failure diagnosis, and a plugin's README and changelog. Clicking one loaded the page in the app's own window. Dropping a link, URL or file where nothing handled it did the same, because the window turns Tauri's drop handler off. Either way a page with no way back replaced the app. These renderers now share one link component. A link to another site opens in the system browser through the app's openExternal bridge, a link to another page of the app's own origin does nothing, a fragment still scrolls in place, and no other scheme reaches the system. Window listeners take every drop that no element handles and do nothing with it. Elements that take drops still get theirs, and text dropped into a text field is still inserted. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
The boot warm-up waited about 4 s for the backend's health route and then warmed up anyway. When another program held the backend's port (AnkiConnect listens on 127.0.0.1:8765 by default), the bind failed, and while the error dialog stayed up the warm-up sent that program the internal secret and the user's provider keys, and answered its account list with keychain entries. The secret guard didn't stop it: the backend sets FLEETIFY_INTERNAL_SECRET before it binds. The shell now sends the backend secrets only once the backend this process started has reported its bind. The warm-up waits for that report and is skipped when the backend fails or never reports. The provider and router reloads, which the key migration and Settings call, send nothing before it. The backend's port is parsed once, from FLEETIFY_BACKEND_PORT, and every sender gets it from the same place, so an invalid value sends them all to the fallback 8765 the backend binds. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
Three fixes to what the startup task does when the embedded backend can't start. The task read the backend's last report before checking whether its task had ended. A bind reported between those two reads, with the task ending, looked like a task that ended without a report: a false "can't start". It now checks whether the reporter is gone first, so a report read after a gone reporter is final. The startup placeholder no longer stays behind the error dialog: the window is hidden first, and the dialog still has no parent window. The dialog named the log folder even when it had never been created (the logger records its folder even when creating it fails). It now names the folder only when it exists, and otherwise says the logs could not be written. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
…ll folder Installed builds showed a blank window. The embedded backend served the UI from dist/ beside the executable, or else from dist/ in the working directory, and no bundle shipped either: frontendDist is only embedded for tauri://, which the app doesn't load. It worked only when launched from a folder holding dist/, such as the repo root. The fallback was a hole as well: a dist/ folder in the launch directory (a cloned repository, say) was served as the app on the origin that holds every app command. The bundle now ships the built UI as a resource (bundle.resources maps ../dist to dist), and a release build serves it only from the install's resource folder, once index.html is there. Missing UI files are a start failure: the backend never starts, and the existing failure path shows "Fleetify's interface files are missing. Please reinstall Fleetify." with the folder and the logs, then quits. tauri-build copies the resources on every build and fails on a missing path, so build.rs creates an empty ../dist when there is none: CI's Rust job and fresh clones build without the frontend. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
On Windows, open::that runs cmd /c start "" "<arg>" with the argument inserted raw: a quote ends the quoting, & chains another command, and %NAME% expands even inside the quotes. URL parsing lets a quote and & into a host, so the markdown link https://x%22&calc.exe&%22y.com/ reached the opener as https://x"&calc.exe&"y.com/ and ran calc. The links the app opens come from markdown it didn't write, provider CLI output and repository remotes. Every link and path the app opens now goes through one module in fleetify-backend. A link must be http or https with a host, or mailto, and its serialized form must hold no quote, whitespace or control character; only that serialized URL is opened. A path must be absolute. On Windows the module launches through ShellExecuteExW (the open crate's shellexecute-on-windows feature), never cmd. Elsewhere it uses open::that as before, which keeps the exit-status error that the GitHub link flow falls back on. A link the renderer asks for that isn't a web or email link gets a message instead of being opened. clippy.toml forbids the open crate's launchers everywhere else, in every crate, and src-tauri no longer depends on open directly. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
…ssions The window's app origin gets its IPC permissions at setup, and in a release build that grant is the only one: without it the interface can call none of the app's commands. A failed grant was only logged, so the app went on to load an interface that couldn't sign in or do anything. A failed grant now stops the start the way missing UI files do: the backend task reports it instead of starting the backend, the window never loads the app, and the error dialog says Fleetify can't start, with the error and the logs folder, then the app quits. tauri panics rather than returning an error when it can't resolve the capability, and release builds unwind, so the grant runs under catch_unwind and a panic counts as a failed grant too. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
Chat links to web pages were target="_blank" links, which Tauri's webview swallows: clicking one did nothing. Citation cards handed any URL a provider sent to the opener. Both now take the same path as the other markdown views: a web or mail link opens in the system browser, a link to a project file still opens the file in the app, and anything else does nothing. A fragment link now scrolls to its element without changing the page's URL. The app reads its own hash, and #logos swaps the whole app for a dev-only logo gallery, so a fragment in any rendered markdown could strand the user there. The drop guard cancelled every unhandled drag, the app's own included, which overrode the sidebar's deliberate no-drop cursor over an illegal target. It now acts only on drags from outside the app that the engine would load (files, links, text, HTML), and leaves the app's session and pane drags to their targets. Text or a link over a text field is still inserted there, but an unhandled file drop is cancelled even there. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
Library's "Open raw file" sent an absolute path to the link opener, which since the last round opens only web and email links, so the click did nothing. The "Open in" menu's "Open folder" called a bridge the preload never defined, so it never worked; its test mocked that missing bridge. Both now go through a new shell_open_path command. It opens an absolute path that exists and is a folder, or a regular file with a document extension: the Markdown, Cursor rule, TOML, JSON, YAML and TypeScript files the Library lists, plus plain text and logs. Anything else gets "This file can't be opened from Fleetify.", because ShellExecute on Windows runs executables, scripts and shortcuts. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
…entials Under WSL, open::that tries wslview first, and wslu hands the URL to PowerShell, where $(...) runs and $env:X expands. The validator let https://x.com/$(calc) through unchanged. A $ or backtick in a host is now refused, and anywhere else it is percent-encoded before the link is opened. Under WSL, a path with either is refused; WSL is detected the way the open crate detects it before trying wslview. A mail link could name a local file to attach (?attach=...), and some mail clients attach it. Mail links may now fill in only to, cc, bcc, subject and body. An http(s) link loses its username and password before the browser sees it. The PR page is built without the credentials an origin remote can hold, since that URL is also handed back to the renderer. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
…t pose as app drags Onboarding messages rendered plain markdown links. The main webview has no navigation guard, so clicking one loaded the website in the app's window in place of the onboarding. They now take the same path as every other markdown link the app shows: the system browser. The dev-only logo gallery, which #logos swaps in for the whole app, now shows only in dev builds; a release build ignores the hash. The drop guard let through any drag carrying one of the app's own drag types. WebView2 carries a web page's custom types across processes, so a drag from a browser could carry the session type next to a link and navigate the window. The app's types now count only for a drag that started in this document; a dragstart the app cancels starts no drag and doesn't count. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
On WebKitGTK, wry tags every postMessage IPC request with the main frame's URL, whichever frame posted it, and Tauri checks the ACL against that URL after comparing only the invoke key. Tauri injects that key into every webview it builds, the browser panel included, so a page there can learn it. A cross-origin frame inside the main webview holding it, such as the Preview pane showing a dev server or any typed URL, could then call every command the app page has, pty_spawn included, since the app origin is granted all of them. The vendored runtime now rewrites the URI of every postMessage request on WebKitGTK to http://postmessage-ipc.invalid/, an origin no capability matches, before Tauri sees it. Tauri answers with its usual "not allowed" error through the caller's error callback, so nothing waits forever: ipc-protocol.js moves a page to postMessage for good after a single failed custom-protocol request, and a dropped message would hang its promise. The app's own IPC goes through the ipc:// custom protocol, whose requests carry the sending frame's own Origin, and keeps working. macOS (wry reports the sending frame's URL) and Windows are unchanged. The patch is marked "FLEETIFY PATCH postmessage-ipc" and documented in FLEETIFY_PATCH.md with the re-vendor steps. The app's tests use its items, check the rewritten origin against the app's real ACL in every way the app runs, and fail if create_ipc_handler stops calling it. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
reqwest sends requests through the proxy in HTTP_PROXY, HTTPS_PROXY or ALL_PROXY, and hyper-util's matcher exempts no loopback address; only NO_PROXY does. Since the window waits for a reqwest poll of the app's URL before it loads the app, a proxy variable pointing at a proxy that isn't running left the window on "Starting Fleetify…" for good. With a proxy that is running, the provider and router keys, the internal secret and the sidecars' bearer token crossed it in plaintext. Every client that talks to the app's own backend, or in debug builds to the Vite dev server, now starts from one builder, fleetify_core::loopback::http_client_builder(), which never uses a proxy: the shell's startup poll, health poll, provider and routing reloads and warm-up, and the memory, dispatch and browser sidecars. fleetify-core is the one crate the shell and the sidecars both depend on. A client that can't be built no longer falls back to reqwest's default client, which honours the proxy. Clients that reach the internet (providers, the issuer, GitHub) are unchanged and keep honouring the user's proxy. The test re-runs the test binary as a child process with the proxy variables pointing at a closed port, so no other test sees them. It checks that reqwest's default client fails there and that a request through the shared builder reaches a local server. A guard keeps these callers on the shared builder. On Linux the webview's own requests also follow an environment proxy; that is a separate change. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
…g things
On Windows, merely checking a path like \\host\share\x.md (exists,
metadata, canonicalize) signs in to that host over SMB and hands it the
user's NTLM hash, and Explorer and ShellExecute connect the same way.
shell_show_item_in_folder checked existence first, and shell_open_path
and open_path looked at whatever path they were given.
The three launchers (open_path for paths the app chose, open_ui_path for
shell_open_path, path_to_reveal for shell_show_item_in_folder and its
fallback) now share one order:
1. On Windows, refuse network and device paths as given (\\server\share,
//server/share, \\?\UNC\..., \\.\..., other \\?\ forms, \??\), before
anything touches the filesystem. Verbatim disk paths (\\?\C:\...) and
normal C:\... paths are allowed. The check is a string helper, tested
on every platform.
2. Resolve the path.
3. Check what it resolved to, so a symlink is judged by where it leads:
from the UI, a folder or a document extension (a .md symlink to a .bat
is refused); under WSL, no character PowerShell acts on (", the
typographic quotes U+201C-U+201E, backtick, $, control characters),
since wslview pastes the resolved path into Start "<path>"; on macOS,
no app bundle or other package, which open would launch.
4. Launch the resolved path, never the original.
Tests inject the filesystem, so they show a network path is refused
before any filesystem call and that the resolved path is what gets
opened. A path on a mapped network drive resolves to its share and still
opens.
Some mail clients split mailto fields on ";" as well as "&", so a field
hidden in a value could get past the field allowlist: a mailto link
whose query holds a ";" is refused.
Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
…he UI The drop guard exempts the app's own drag types only while one of the app's drags is in flight, and that flag could stick. Any uncancelled dragstart set it, a link dragged inside the page included, and when a drag's source left the document mid-drag its dragend never reached the window. A stuck flag let a later drag from outside carrying an app type past the guard, which WebView2 allows. The flag is now set only by a dragstart carrying an app type. It clears when the drag ends at its source, even a detached one (a one-time dragend listener on the source), and at the next press, should no dragend come at all. git_context sent the origin remote to the renderer as remoteHttpsUrl with any embedded user:token@. It now goes through without_credentials, as the PR page URL already does. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
dorukozgen
marked this pull request as ready for review
November 18, 2026 00:57
secrets_port returned the backend's port once it had reported its bind. Code scanning's name-based heuristics read the word "secret" as sensitive data and flagged the loopback URLs built from that port as cleartext transmission. The value is a port number, and the requests never leave 127.0.0.1. port_if_bound says what the helper returns. Behaviour is unchanged. Signed-off-by: Doruk Özgen <140007919+dorukozgen@users.noreply.github.com>
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Release-readiness work ahead of Fleetify's first public release.
Each change landed as its own commit and passed a task review. Several needed fix rounds, and the whole branch then passed a final review.
What changes
Production configuration
https://fleetify.dev) and API audience. They ignoreFLEETIFY_ISSUER,FLEETIFY_RESOURCE,FLEETIFY_AUDIENCE,FLEETIFY_NOAUTHand.envfiles.Sign-in and keychain
fleet-wipeclears Fleetify's Secret Service items and never prints keychain usernames or account IDs.Privacy and telemetry
~.docs/ANALYTICS.mdandCLAUDE.mdnow describe exactly what the code sends. The "Crash reports" switch, which controlled nothing, is gone.fleet.config.jsonis backed up under a name based on its content instead of silently losing every setting. Failed settings saves are reported in the UI.Startup and release builds
dist/directory, which the app would then have served as its UI.HTTP_PROXY/ALL_PROXY. A configured proxy therefore can't see them, and a proxy that isn't running can't stall startup.App commands in release builds
Release builds can call the app's commands. An app ACL manifest lists every command, and the build fails when that list drifts from the registered handlers.
Only the app gets them. The grant covers the exact backend address of the current run, for the main window's webview only. The embedded browser panel never gets it. On Linux, frames inside the app, such as the Preview pane, can't borrow the app page's permissions either.
Links open in the system browser instead of replacing the app. This covers:
Dropping a URL on the window no longer navigates away from the app.
One validated opener. Every link and local path the app opens goes through one module, and a lint rule bans opening anything around it.
cmd.Library and Open-in. Library → "Open raw file" and Open in → "Open folder" work again.
Git attribution
Co-Authored-Bytrailer and PR footer. It stays on by default.Robustness
Keyboard
Plugins
Release tooling and licence
scripts/release/scan-secrets.mjsscans build artefacts for leaked keys. It gets wired into the release pipeline in a follow-up PR.Notes
FLEETIFY_ISSUERis unset. Before, they used production.npm run wipereports the keychain step as FAILED.Testing
-D warnings, eslint, tsc and the sidecar drift check pass. The advisory suites show only failures that already exist onmain: Rust, 1477 passed and 1 failed; vitest, 1370 passed and 5 failed..env, hostile environment variables and a hostiledist/in the launch folder.dist/is ignored. Sign in openshttps://fleetify.dev/api/auth/oauth2/authorize?…&resource=https%3A%2F%2Ffleetify.dev%2Fapi, both on the default port and on port 8899.Follow-up before v0.2.0
A hardening PR lands before the first release is cut: