Skip to content

fix: release readiness for the first public release - #2

Merged
dorukozgen merged 76 commits into
mainfrom
fix/release-readiness
Nov 18, 2026
Merged

dorukozgen merged 76 commits into
mainfrom
fix/release-readiness

Conversation

@dorukozgen

@dorukozgen dorukozgen commented Nov 16, 2026 •

Copy link
Copy Markdown
Contributor

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

  • Release builds pin the production issuer (https://fleetify.dev) and API audience. They ignore FLEETIFY_ISSUER, FLEETIFY_RESOURCE, FLEETIFY_AUDIENCE, FLEETIFY_NOAUTH and .env files.

Sign-in and keychain

  • On Linux, sign-in and API keys now survive a reboot, because they are stored in the Secret Service. The kernel keyring used before was cleared at every reboot.
  • A banner warns when the sign-in can't be saved to the keychain.
  • fleet-wipe clears Fleetify's Secret Service items and never prints keychain usernames or account IDs.

Privacy and telemetry

  • Dashboard sync (Fleetify cloud) is now a real switch:
    • on by default, and disclosed during onboarding with a "Turn it off" choice; on a new install nothing is sent until that step is answered;
    • turned on or off live from Settings → Privacy, and turning it off purges the queue;
    • a settings file that exists but can't be read or parsed keeps sync off;
    • rows queued by older builds are dropped once.
  • Dashboard sync sends less:
    • no activity summaries, which used to include shell commands, file paths and sub-agent prompts;
    • the project folder name instead of the full path, with the home folder sent as ~.
  • Product analytics (PostHog):
    • posthog-js isn't loaded until the user opts in;
    • autocapture, feature flags, dead-click and exception capture are off;
    • identify sends the user ID only, with no name or email;
    • the posthog-js version is pinned.
  • Accurate descriptions. The Settings → Privacy card, the onboarding copy, docs/ANALYTICS.md and CLAUDE.md now describe exactly what the code sends. The "Crash reports" switch, which controlled nothing, is gone.
  • Safer settings files. A corrupt fleet.config.json is 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

  • Installed builds show their UI. The interface files now ship inside every package, and release builds serve them only from the install folder. Before this, an installed copy showed a blank window. The only exception was a launch from a folder that contained a dist/ directory, which the app would then have served as its UI.
  • No more dead "Could not connect" page. The window opens on a small "Starting Fleetify…" page and loads the app only after the embedded backend answers. A slow start, for example a locked keychain, now just waits.
  • A clear failure instead of a hang. If the backend can't start (port taken, unreadable settings, missing interface files), a dialog says why and where the logs are, and the app quits.
  • Keys go only to Fleetify's own backend. Provider API keys and the internal secret are sent only after that backend has started. Before, another program holding the port could receive them.
  • One backend port. It is read once and used everywhere.
  • Internal calls skip system proxies. The app's calls to its own backend and sidecars never go through 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:

    • the markdown views: project preview, agent plans, AI review and diagnosis, plugin pages;
    • chat and citation cards;
    • onboarding.

    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.

    • Links: only web and email links are accepted. Embedded credentials are stripped, and mail links are limited to the standard fields.
    • Local paths: they must be absolute and are resolved before they are checked. Network paths, app bundles and executables are refused.
    • On Windows: links and paths open with ShellExecute, never cmd.
  • Library and Open-in. Library → "Open raw file" and Open in → "Open folder" work again.

Git attribution

  • Settings → General → Attribution lets users turn off Fleetify's Co-Authored-By trailer and PR footer. It stays on by default.

Robustness

  • Non-ASCII text (Turkish, emoji) no longer crashes:
    • AI commit-message generation;
    • log previews;
    • the reveng sidecar;
    • the gh device-code parser.
  • Transcripts shown outside the chat view, in the Workflows run detail and the Agent pane, are no longer evicted. Fetched transcripts are parsed before they are stored.
  • A render error now shows a recovery screen instead of a blank window.

Keyboard

  • Stop-all (Mod+Shift+A) works with Caps Lock on, on macOS, and while Settings or Library is open.
  • Escape:
    • stops only the focused pane's stream;
    • never stops it while closing a modal or a popover, or when pressed in a field outside the chat.
  • Permission cards:
    • only the focused pane's card answers keys;
    • Ctrl+Enter works on Windows and Linux;
    • a key typed in a text field never answers a card.
  • Browser element picks land in the pane that armed Select.
  • Mod+Shift+. works on Turkish Q keyboards without taking over Ctrl+/ on AZERTY.

Plugins

  • Icon fetching:
    • the DNS resolver pins vetted addresses, so there is no gap between check and connect;
    • IPv6 is limited to an allowlist;
    • reserved ranges and trailing-dot names are refused.
  • Each icon is fetched once, in parallel, within a 3 s budget. An icon the backend can't inline never reaches the WebView as a URL.
  • README and changelog images from unknown hosts load only on click.

Release tooling and licence

  • scripts/release/scan-secrets.mjs scans build artefacts for leaked keys. It gets wired into the release pipeline in a follow-up PR.
  • The project is relicensed under Apache-2.0, with a NOTICE file.

Notes

  • Debug builds now send dashboard-sync WebSocket traffic to the local IdP when FLEETIFY_ISSUER is unset. Before, they used production.
  • Linux needs a Secret Service provider (GNOME Keyring or KWallet) to stay signed in. Without one, the app warns and npm run wipe reports the keychain step as FAILED.
  • Icons: icon fetches no longer go through a system proxy. An icon the backend can't fetch shows the fallback glyph.

Testing

  • CI gates. On the head commit, rustfmt, clippy on Rust 1.100 with -D warnings, eslint, tsc and the sidecar drift check pass. The advisory suites show only failures that already exist on main: Rust, 1477 passed and 1 failed; vitest, 1370 passed and 5 failed.
  • Regression tests. Each fix added its regression tests first, and many were mutation-checked.
  • Isolated launch of the production AppImage. The check runs under Xvfb, in a private D-Bus session without a Secret Service, with a temporary home. It adds a hostile .env, hostile environment variables and a hostile dist/ in the launch folder.
    • Earlier runs of this check found the three release blockers fixed here: the dead window, commands refused by the ACL, and the missing UI files.
    • On the head commit the welcome screen appears, and the hostile dist/ is ignored. Sign in opens https://fleetify.dev/api/auth/oauth2/authorize?…&resource=https%3A%2F%2Ffleetify.dev%2Fapi, both on the default port and on port 8899.
  • Linux frame isolation. On WebKitGTK, a cross-origin frame inside the app that sent a correctly keyed IPC message was allowed before this change. After it, the message is refused, in both debug and release builds. The app's own IPC keeps working.
  • Real machines. A full smoke test on Linux, macOS and Windows happens at the release candidate.

Follow-up before v0.2.0

A hardening PR lands before the first release is cut:

  • a Content Security Policy for the app UI, served together with the UI from the app's embedded assets;
  • hardened request handling for the local backend;
  • proxy handling for the app's own page loads on Linux, and removal of an unused local endpoint;
  • a Rust-side config helper that holds the write lock across read-merge-write;
  • the same click-to-load rule for images in chat replies and workspace markdown;
  • single-instance handling, then a port fallback when the default port is taken;
  • startup robustness fixes, the remaining pre-existing test failures, and minor doc and comment fixes.

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>
Comment thread crates/fleet-wipe/src/main.rs Dismissed
Comment thread crates/fleet-wipe/src/main.rs Fixed
Comment thread crates/fleet-wipe/src/main.rs Fixed
Comment thread crates/fleet-wipe/src/main.rs Fixed
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
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>
@dorukozgen
dorukozgen merged commit c3dc869 into main Nov 18, 2026
8 checks passed
@dorukozgen
dorukozgen deleted the fix/release-readiness branch November 18, 2026 01:19
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants