Compare commits

..
7 Commits
Author SHA1 Message Date
paseo-ai[bot] 1a45b46840 fix: update lockfile signatures and Nix hash [skip ci] 2026-11-19 14:40:12 +00:00
Mohamed Boudra 93ff95b20f Reconcile 0.17.0 beta metadata (#10233)
* docs(changelog): prepare 0.17.0 beta

(cherry picked from commit fbbfcf42bc)

* chore(release): cut 0.17.0-beta.1

(cherry picked from commit 6c89950b2e)
2026-11-19 21:31:18 +07:00
Mohamed Boudra d5d385afa7 Show each provider's state in the list and open one provider page everywhere (#9661)
* fix(app): leave providers that are not installed out of the model picker

An agent's own provider stays in its selector, labelled Unavailable.

* feat(app): open a provider's detail as a Settings page or a sheet

Settings → Providers now pushes a provider page, like Projects and Plugins;
the model picker gear and setup keep a sheet. Both frame one body, ordered
error, Enabled, Installation, Models, Troubleshooting, Danger zone, so the
old sheet's sticky footer and Retry button are gone. Refresh lives once, in
the Troubleshooting status row.

The page header (back link, icon, title) moves into the shared settings kit
so projects, plugins and providers line up on the same rails.

* feat(app): show each provider's version, updates and faults in the list

Each row now says how its provider is: version and model count, Update
available, a spinner while an update runs, a red dot with the error, or
Not installed / Disabled. Only a broken provider gets a dot, and a
provider that is not installed has no switch, since the model picker
already leaves it out. The kebab is gone; Remove lives on the detail.

Rows read the same installation and update queries as the detail, so
opening a provider costs no new requests. Hosts without
providerInstallation still get a correct list from the snapshot alone.

Add provider is a "+ Provider" button in the header and a muted last row;
both open one sheet with search and catalog rows, replacing the tile grid.
After Add, the new provider's detail opens.

The row is the settings kit's detail row, which gains a leading icon, a
hint status (spinner, error dot, or a held line) and a control before the
chevron. The Unistyles test stub now applies withUnistyles theme mappings,
so browser tests render components that read colours through the theme.

* feat(app): open setup's provider pages over the setup card

The detail and Add provider sheets take the setup card's frame and a back
arrow, so they read as pages of setup instead of a sheet over it. The step
is renamed "Your providers" to match the list it shows.

* docs: describe the provider list and pages as they are now

* fix(app): keep settings rows one height and on one icon rail on phones

On touch layouts a switch reserves a 44px control, so in the provider list
rows with a switch stood 10px taller than "Not installed" rows without one.
Card rows now reserve a default control's height, the rule nested rows
already follow.

A compact SettingsRow wrapped with a full `gap`, which added 12px on top of
the leading slot's margin: catalog icons sat 24px from their labels instead
of 12px. The wrap only needs space between lines, so it uses `rowGap`.

* fix(app): keep a provider row's error to one line

A long or multi-line error wrapped the hint to two lines with the dot
centred between them. The row cuts it to one line; the provider's page
shows it in full.

* fix(app): title a provider's Settings page like a project's

The page title and the detail header both named the provider. The screen
now titles it "Providers" and the page names the provider once, the way a
project's page does.

* fix(app): keep a settings row's switch out of the row's button

The provider row's switch rendered inside the row's <button>. That is
invalid markup, and keys reached both: Enter on the switch toggled it and
also opened the provider's page, and Space on it opened the page without
toggling.

SettingsRowHeader now lays its press target under the row's content as a
sibling of the control. The content lets presses through to the button and
stays out of the accessibility tree, where the button's label already names
the row. Hover is tracked on the row, so it holds over the switch.

* fix(app): reserve a control's height only on rows that open something

The previous change gave every card row a control's minimum height and
the design doc said so, but rows built directly on settingsStyles.row
(66 uses) never got it: a single-line row was 48px or 64px depending on
which code path built it.

The minimum now belongs to SettingsRowHeader, the row with an optional
control slot, so a list where only some rows carry a switch keeps one
height. SettingsRow and hand-built rows take their content's height again,
as on the base branch, and the doc states the narrower rule.

* test(app): give the Unistyles stub the light theme's full colours

Since the stub started applying withUnistyles theme mappings, a mapping
reading a colour the stub's theme lacked crashed: the markdown styles read
colors.terminal and failed the plan card disclosure tests. The stub's
colours now start from the light theme, with its own values pinned on top.

* test(app): find the provider page's buttons in the compact sheet

On compact layouts AdaptiveModalSheet puts its testID on the header only,
so buttons in the page body cannot be found inside it. The spec looks them
up on the page, as it did before the page moved into the sheet.

* fix(app): let screen readers read a settings row's state line

The row's button carries the row's name as its label, so only the title is hidden from assistive tech now; the hint below it (a provider's version, error or Not installed) is read again.

The Enter-on-switch test now dispatches its key events synchronously inside one act. An awaited keyboard call let the Switch's animation run a frame after the test, which Vitest reported as an unhandled error and failed the run.

* fix(app): don't open a provider's page after its Add sheet was closed

Adding a provider waits for the daemon to probe it. If the user closed the sheet during that wait, the completed add still navigated to the provider's page. The add now remembers which sheet session started it and only opens the page if that session is still current.

* fix(app): say Not installed for a disabled provider that is not installed

A disabled provider's snapshot status is unavailable, so the row said Disabled even when the binary was missing. The installation inspection is checked first, so Not installed wins over Disabled.

* fix(app): keep a saved provider choice visible when it is not installed

The provider picker drops unavailable providers. A schedule or metadata-generation setting saved against such a provider then showed Select model. The picker now keeps the saved provider, labelled Unavailable, so the user sees what is set and can change it.

* test(app): wait for an added catalog provider's probe before continuing

Adding a provider opens its page only after the daemon probes it, which can outlast the default expect timeout on CI.

* refactor(app): name the provider picker's connection and saved-choice options

Callers passed a bare true to reach the saved-choice argument.

* fix(app): show a provider page's loading and not-found states

A provider page opened from its URL (a reload, a cold start, a shared link) rendered its title over nothing until the host's providers arrived, and forever when the id named a provider the host doesn't have. The page body now says Loading..., that the host is offline, that the providers couldn't be read, or that the provider isn't on this host, in the same notice card the provider list uses when it is offline. The page and both sheet frames share the body.

* fix(app): don't call a just-removed provider missing while its page closes

The daemon can publish the provider list without the removed provider before it answers the config patch, so the page said "This provider isn't on this host" until the answer arrived and it navigated away; in a sheet, through the exit animation as well. A page that has shown its provider now shows nothing once it leaves the list. The not-found notice is for a page that never found its provider. The removal e2e holds the config answer so it always sees that order.

* fix(app): show the not-found notice when a provider is removed elsewhere

The page hid the notice for any provider it had shown before, to cover its own Remove. A removal from another client, the CLI or a plugin then left the page blank with no way to tell why. The page now owns its Remove: while that runs and once it succeeds the body shows nothing, and any other absence says the provider isn't on this host.

The removal e2e routes only the e2e daemon's socket, so the fixture's port-6767 guard stays in force.

* fix(app): show progress on the provider page's in-flight buttons

Remove, Add model and the diagnostic re-run now show their work on the
pressed control, like the page's Refresh and Update: a spinner, no
further presses and, on a labelled button, "Removing..." or "Adding...".

Remove kept its label and only disabled itself, and the page went blank
mid-removal: the daemon publishes the provider list without the removed
provider before it answers the config patch, so the body had nothing to
show and each frame's title fell back to the raw id. The removal now
keeps the entry the user confirmed, and one hook feeds the frame's title
and the body, so both keep showing the provider until the page closes.
The in-flight state also starts after confirmation, not while the
dialog is open.

The diagnostic sheet's header icon buttons had lost the base branch's
spinner and dimming; SheetHeaderIconButton now takes loading and
disabled, the way Button does.

* fix(app): don't leave a re-added provider's sheet stuck on Removing...

The setup step and the model picker's gear keep a provider's sheet
mounted after it closes, keyed by provider. A finished removal stayed
set in that sheet, so adding the same provider back reopened it with
Remove spinning and disabled. A finished removal now ends when the host
lists the provider again.

* fix(app): keep the composer's remembered provider in its picker

The picker leaves out providers that aren't installed, except the one
holding the picker's current choice. The schedule form and metadata page
passed that choice; the new-agent composer didn't, so a remembered
provider not installed on this host vanished from the picker and the
trigger read "Select model" with no reason given. The builder now requires
every caller to say what its current choice is, or null.

* fix(app): guide a missing catalog provider's install and keep custom models while one fails

A provider added from the Add provider catalog runs through the generic ACP client, which reports
no installation, so its page said nothing when the CLI was missing. The page now shows the
Installation section's Not installed row with Install opening the catalog's guide. A link the
host supplies still wins.

Custom models live in config, so the page lists them and offers Add model whenever the provider
is enabled and installed, including while it fails. The provider's own models, and the search
over them, still show only while it runs.

* fix(app): make settings rows pressable on iOS and Android

React Native 0.86 no longer exports StyleSheet.absoluteFillObject, and
Unistyles' native StyleSheet copies it from React Native, so the spread
was empty there. The row's press target then had no size: on Android,
tapping a provider row or a Voice row did nothing. Web was unaffected
because Unistyles' web StyleSheet still defines the key. Use
StyleSheet.absoluteFill, as the rest of the app does.

* fix(app): let setup's provider sheets leave out the close button again

The base's sheet header rewrite dropped SheetHeaderView's showCloseButton,
which the provider page and Add provider sheets pass when setup's back
arrow is the only way out. Restore it on the header.

* test(app): prove a refresh clears a failed update from the provider's row

The update-failure journey now also walks the provider list: after Refresh
on the page the row reads its version and model count with no error dot,
and a refresh from another client clears a row that is open in the list.
Without the provider.installation.update.cleared handling both row checks
fail. The helper's Refresh now uses the page's Troubleshooting button,
since Settings opens the provider as a page, not a sheet.

* fix(app): show a catalog provider's install guide on hosts that cannot report installations

A host without providerInstallation returns an unsupported installation,
which the page passed through, so a catalog provider whose CLI is missing
showed no Installation section and no guide anywhere. The guide is the
app's own catalog data, so the page builds the same Not installed row
from it on those hosts.
2026-11-19 21:30:31 +07:00
Mohamed Boudra 86ebdedcbe Apply content width presets to open chats (#10231)
* fix(app): apply content width presets to open chats

Retained rows kept the numeric width in their generated web styles. Use a CSS variable so the timeline, composer, and Markdown previews follow the same preference while mounted. Reserve the outline gutter when the outline is enabled on a wide pane.

* fix(app): keep capped chats centered beside the outline

Reserve the left outline gutter and match it on the right when the selected column fits between both gutters.
2026-11-19 21:12:36 +07:00
Mohamed Boudra 4d29ee415a Show provider versions and run provider updates from provider settings (#9568)
* feat(providers): show installed version and install link in provider settings

Providers can now declare `installation`: install and update links plus an
`inspect` callback that reports installed state and an opaque version string.
Built-in clients and plugin providers share one contract; plugins receive the
daemon-resolved launch with `resolved: false` when the executable is missing,
so they can report not installed instead of failing.

The daemon calls `inspect` only on the new
`provider.installation.inspect.request` RPC, never from availability probing,
discovery or session creation, so a slow version probe cannot delay agents.
Results are cached per client for 30s, deadlined at 20s, and links survive a
failed probe. The app gates the provider sheet's Installation row on
`server_info.features.providerInstallation`, so older hosts show nothing new.

* feat(providers): show available updates in provider settings

Providers can now declare `installation.checkForUpdates`, returning
`current`, `available` with opaque `versions` and `message`, or `unknown`.
The provider decides what counts as newer; Paseo shows its answer as
written and never parses or compares versions.

The check is its own RPC, `provider.installation.check_updates`, so the
installed version never waits on a network lookup. The daemon caches a
conclusive answer for an hour and an inconclusive one for 30s, shares
in-flight calls, and deadlines the call at 25s, below the plugin RPC
timeout. A throw or timeout comes back as `error`, which the app shows as
inconclusive, never as up to date. The sheet's Refresh bypasses the cache.

Codex and Claude Code read the release source their own updaters use:
the Homebrew cask for cask installs, otherwise the GitHub latest release
for Codex and the configured `autoUpdatesChannel` for Claude Code.
`codex doctor --json` reports the same answer but scans local state and
took close to a minute, so it is not used. Muse compares its build with
the launcher's channel manifest, the same rule the launcher updates by.

The install link now shows whenever the provider declares `installUrl`
and is not reported installed: the Install button for `not_installed`, a
quieter "Install instructions" link when the check failed or the
provider only links to a guide.

* feat(providers): run provider updates from provider settings

Providers can declare `update(context)`, and the Installation section shows an Update
button when an update is available. The daemon owns the operation: one per provider,
joined by later requests, kept in memory past client disconnects, streamed to subscribers
through an owned subscription, and aborted only when the daemon stops. The provider's
answer is the outcome; the daemon adds no verification. After success it drops the cached
inspection and update check and refreshes discovery, without restarting agents.

Codex and Claude run their own `update` subcommand and pass the output through. Muse has
no update subcommand, so it does not declare one.

Updater output is capped at 64 KiB per update so a chatty updater cannot grow daemon memory.
Starting an update requires daemon.manage because it runs commands on the host.

* feat(providers): report installation for the remaining providers

Copilot, OpenCode, Pi, Oh My Pi, Antigravity and Hoplite now show an
install link and the installed version in provider settings. Each one
declares only what its CLI offers:

- Update checks ask the source the CLI's own updater reads: Pi's
  latest-version endpoint, `omp update --check`, and Hoplite's
  latest.json. Copilot and OpenCode resolve their release inside the
  binary, so they declare no check.
- Updates run the CLI's own command: `copilot update`, `opencode
  upgrade`, `pi update --self` (leaves Pi packages alone), `omp update`.
  Antigravity and Hoplite document no self-update.

OpenCode's success message asks for a daemon restart, because all
OpenCode agents share one server that keeps running the old version.

* docs(providers): document the provider installation contract

Plugin authors get the contract in the provider guide, with a worked
example that reports a version, checks for an update and runs the CLI's
own updater, and every field, deadline and cache in the reference.
The internal provider and plugin docs record why the three callbacks are
separate, that versions are opaque, that Paseo adds no verification to
an update, and how the plugin bridge carries and cancels each request.

* chore(protocol): mark provider installation as shipping in v0.17.0

main is on the 0.16 beta series, and a promotion ships the tested beta's
content without pulling from main, so this lands in the next minor.

* fix(app): bound update output and show refresh failures in provider settings

The screen appended every progress chunk with no limit while open, so a
noisy updater grew memory and never showed the truncation note that a
reopened screen shows. Progress now folds with the daemon's 64 KiB limit.

A manual refresh stored its result and failure outside the queries the
screen reads, so a failed refresh brought back the old answer with no
warning. Refresh now runs through those queries. It passes staleTime 0
because the app's default staleTime of Infinity would otherwise answer
from the cache.

The not-connected error uses the translated string the i18n check
requires.

* fix(providers): keep update checks in step with the installed version

A conclusive check is cached for an hour and was not tied to the version
it answered for. After a CLI updated outside Paseo, settings showed the
new version and still offered Update to it. When an inspection reports a
different version, the cached check is dropped. Versions are compared
for equality, so they stay opaque.

The release comparison dropped prerelease suffixes, so Codex
0.200.0-alpha.1 looked current against 0.200.0. A prerelease now comes
before the release with the same numbers. Two different prereleases of
the same release are reported as unknown.

* docs(providers): say when Update instructions shows

* fix(providers): reuse a cached update check only for the version it answered

The previous fix dropped the cached check after an inspection settled
with a new version. On reopen the app sends inspect and check together,
so the check answered from the stale entry before the inspection
settled. A cached check now records the installed version it was
computed against and is reused only when the current inspection, shared
if in flight, reports the same version.

* fix(app): refresh provider version after an update settles while disconnected

The installation and update queries were invalidated only by a live
succeeded progress event. A connection dropped mid-update delivered the
settled operation as a snapshot on reconnect, which left the old version
and Update on screen. A success the view saw running now rereads them
whether it arrives as progress or as a snapshot.

* fix(providers): keep update checks within their own deadline

Tying a cached check to its version made every check wait for a fresh
inspection, which could add the 20 s inspect deadline to the 25 s check
deadline. A check now never starts an inspection. It waits on one only
when the inspection is cached or already running and the check would
reuse a cached answer. When it asks the provider, it records the version
afterwards.

* test(app): assert provider installation states are visible

* fix(providers): share one update check when two clients reopen after a version change

* fix(muse): report the build the update check compares

Paseo reuses a cached update check while inspect reports the same
version string. Muse reported 1.4.18 but compared its build
(1.4.18-R8600.1), so a new build of the same release kept the stale
"Update available" for up to an hour. The contract docs now say to
include everything the check compares in the reported version.

* test(app): scroll custom model rows into view before checking them

The provider sheet now shows an Installation section above the model
lists. At 390x1000 the custom model row sits under the sheet footer
until scrolled. The spec checks that a long model id leaves its Remove
button reachable. It had assumed the row needed no vertical scroll.

* test(app): keep the custom model check sensitive to a Remove button pushed off the sheet

scrollIntoViewIfNeeded on the Remove button scrolled the overflow-hidden model
card sideways too, so the check passed with the long-id layout fix undone.
Scroll only the Custom models heading into view, which moves the sheet
vertically and leaves the card at scrollLeft 0. With the layout fix undone the
spec now fails at 1200px and 390px again.

* feat(app): offer provider updates whether or not an update check answers

Update and Update instructions lived inside the row that appeared only after
checkForUpdates answered, so Copilot and OpenCode, which declare update but no
check, never offered either. A check is a convenience: the Updates row now
shows for an installed provider that offers an update, keeps Update or Update
instructions in place in every check state (none, checking, up to date,
available, couldn't check), and shows what the check knows as a hint beside
it. A provider that offers no update still shows the check's answer once it
has one. The daemon already ran update without a check; a test now says so.

* fix(app): let update output scroll inside the provider sheet on Android

The output box is a ScrollView nested in the sheet's scrolling body. Android hands the drag to the outer ScrollView unless the inner one sets nestedScrollEnabled, so only the last 240px of a long update's output was readable. The tool-call detail views set the same flag.

* fix(app): show one progress indicator per provider update and refresh

While an update ran, the Update button and the update's row each showed a spinner. The button's
spinner also widened it, and the row's leading spinner shifted the title when the update settled.
The update's row now owns progress from the tap until the update settles: it shows the update
starting before the host answers, so the indicator never moves, and the Update button only
disables.

Refresh blanked the Installation rows while the provider was asked again, then moved "Checking…"
from the Version row to the Updates row. The rows now keep their last answers until the new ones
arrive, and the Refresh button shows the refresh until both the models and the installation are
read again.

* fix(app): show a provider update's progress on its Update button

The pressed button carries an action's progress everywhere else in Settings: Button's own
loading state with a present-participle label, as Browser data's Clear and Project settings'
Save do. Update now does the same, reading "Updating..." from the tap until the update settles,
and the update's row holds only the output while it runs, then the result. This replaces the
row-owned spinner from the previous commit, which no other surface uses.

The installation's in-flight labels use three dots like their siblings.

* fix(app): keep a running update's progress visible whatever the inspection reads

Update carries the update's progress, but its row rendered only while the inspection read
"installed". An inspection that ran during the update (on reopen or Refresh) could read loading,
not installed or failed while the binary was replaced, and the sheet then showed nothing about the
running update. The Updates row now stays while an update runs.

* fix(server): show and update the provider CLI its agents launch

The installation contract found the CLI on the daemon's PATH, while agents
spawn the bare command with the provider's environment. A provider whose env
sets PATH could launch one copy and show and update another, so an update
succeeded while new agents kept the old version. The CLI is now resolved with
the provider's environment.

The section test's check-state table now always names the text it expects, so
no case can skip its assertion.

* test(server): name the provider PATH test for what it shows

The availability check that gates a Copilot spawn still looks on the daemon's
PATH, so the copy on the provider's PATH is not always the one agents launch.

* test(antigravity-provider): read the version from the CLI, not its acp subcommand

Antigravity now launches `agy acp --disable-telemetry`, so the launch the
installation receives ends with the ACP subcommand. The version read drops it,
since `agy acp --version` starts the ACP server.

* feat(plugin): pass the inspected version to checkForUpdates

checkForUpdates now receives installedVersion, the version inspect reported, and
the daemon keys the cached answer on it. Before, each provider read its version
a second time and the daemon recorded which version a cached check answered
for, so a check could compare a different version than the one shown, and a
plugin had to put everything its check compared into the reported version.

An update check now waits for the provider's inspection (shared with a
concurrent inspect, refreshed with it), answers Not installed or the
inspection's error without asking the provider, and is asked again once the
inspection reports a different version.

* fix(server): clear a failed provider update when the provider is refreshed

The daemon kept a provider's last update for its whole lifetime, so a failed
update stayed the current update until a later update succeeded or the daemon
restarted, and the provider looked broken after the user fixed it. A refresh
of the provider's installation or update check now drops a failed result. A
running update is never dropped.

* docs(server): say which agents look up the provider CLI on its PATH

* fix(server): tell open provider views when a refresh drops a failed update

A refresh deleted the failed update on the daemon but sent nothing, so a view
already observing the provider's updates, in this client or another one, kept
showing the failure until it observed again. The daemon now pushes
provider.installation.update.cleared with the dropped operation's id to every
subscriber, and the app clears the update it shows when the ids match.
2026-11-19 20:56:00 +07:00
paseo-bot[bot] 32218adfec Read a restored worktree again instead of serving its not-git snapshot (#10224)
When a worktree folder disappears, the workspace git service can cache a
not-git snapshot before it notices and suspends the workspace. After the
folder comes back, a plain getSnapshot returned that cached snapshot
before it tried to resume, so checkout status said "not a git repository"
until the 60 s missing-folder probe. The Changes panel of a just-restored
worktree had no repository header during that time.

Resume a suspended workspace first, then serve the cached snapshot.

This made e2e worktree-restore.spec.ts:167 flaky in CI.

Co-authored-by: paseo-bot[bot] <266920839+paseo-bot[bot]@users.noreply.github.com>
2026-11-19 12:48:36 +00:00
Matt Pilsbury 4929ed5a0f fix(codex): restore subagent status after reopen and rewind (#10171)
* fix(codex): settle historical collaboration subagents

* fix(codex): reconcile replayed collaboration with child turns
2026-11-19 12:07:48 +00:00
165 changed files with 11485 additions and 2933 deletions
+6 -6
View File
@@ -134,7 +134,7 @@ A section or group explains itself through the `info` prop on `<SettingsSection>
Cards inside a section sit closer than sections. Rows inside a card touch — only the divider separates them. The rhythm is page → spacious; section → spacious; card → tight.
Rows have generous vertical padding: roughly 16px of content plus 16px of vertical padding for settings rows, 8–12px for sidebar list items where many rows must fit. Compressing rows below the established density to fit more on the screen is wrong. Too many rows means more cards or more sections, not smaller rows.
Rows have generous vertical padding: roughly 16px of content plus 16px of vertical padding for settings rows, 8–12px for sidebar list items where many rows must fit. A row that opens something (`<SettingsDetailRow>`, a collapsible row's header) is at least as tall as one holding a default control, so a list where only some of those rows carry a switch keeps one row height. Other rows take their content's height. Compressing rows below the established density to fit more on the screen is wrong. Too many rows means more cards or more sections, not smaller rows.
Rows revealed under a `<SettingsCollapsibleRow>` are nested rows, one step smaller than card rows: 8px of vertical padding, `fontSize.sm` text, `sm` controls, and one fixed height so rows with and without a trailing button line up. The collapsible row sets this for everything under it (`packages/app/src/components/settings/row-density.tsx`). Never pass a density to a row, and never pad or resize a nested row by hand. Settings rows that share a menu surface with menu rows, such as Usage's options, go inside `<MenuSettingsRows>`, which puts their labels on the menu rows' label rail (`menuRowContentInset`).
@@ -207,11 +207,11 @@ Terminology:
## 11. States
Loading is inline by default. `<LoadingSpinner size={14} color={foregroundMuted} />` sits next to the thing it relates to (`packages/app/src/screens/settings/providers-section.tsx:227-231`). Page-level loading is a centered `<LoadingSpinner size="large">` (`packages/app/src/screens/sessions-screen.tsx:69-72`). Card-level loading is a single short line, not a spinner. In-row dropdown items use `<DropdownMenuItem status="pending" pendingLabel="Removing...">`; the menu item handles its own pending state.
Loading is inline by default. `<LoadingSpinner size={14} color={foregroundMuted} />` leads the line it relates to, never trails a label: a settings row's hint takes `hintStatus="busy"` while its work runs, and `hintStatus="pending"` holds the line with a skeleton until its value is read (`packages/app/src/components/settings/row-header.tsx`). Page-level loading is a centered `<LoadingSpinner size="large">` (`packages/app/src/screens/sessions-screen.tsx:69-72`). Card-level loading is a single short line, not a spinner. In-row dropdown items use `<DropdownMenuItem status="pending" pendingLabel="Removing...">`; the menu item handles its own pending state.
Screen-level empty states use a centered, muted noun phrase and at most one ghost button (`packages/app/src/screens/sessions-screen.tsx`). Sidebar list empty states use a quiet bordered card with a left-aligned `sm` title, a muted `sm` description, and `sm` `<Button>` actions. Use `secondary` for the primary action and `outline` for a secondary action (`packages/app/src/components/sidebar/empty-states.tsx`). Keep both forms short and free of illustrations.
Inline errors are a single sentence in `palette.red[300]` `xs`, sitting under the field or inside the card it relates to (`packages/app/src/screens/settings/providers-section.tsx:115-119`).
Inline errors are a single sentence in `palette.red[300]` `xs`, sitting under the field or inside the card it relates to (`packages/app/src/components/ui/form-field.tsx`). A settings row that is broken says so in its hint with `hintStatus="error"`: a red dot and the error in `statusDanger`.
Page-level alerts — informational notices, success confirmations, warnings, or recoverable errors that need a small visible block on the page — use `<Alert>` (`packages/app/src/components/ui/alert.tsx`). Variants: `default`, `info`, `success`, `warning`, `error`. The chrome is quiet by design: a 1px tinted border, transparent background, a small variant-tinted icon, the title in the variant accent, the description in `foregroundMuted`. Actions go in the `children` slot as `<Button variant="outline">` — recovery actions are low-frequency and outline keeps them quiet alongside the alert's accent (`packages/app/src/screens/project-settings-screen.tsx`). One `<Alert>` at a time per region.
@@ -233,13 +233,13 @@ Changing state must not move the layout. A row that grows when its badge arrives
The row anatomy is a content column with an optional trailing slot. Inside a card the row is `settingsStyles.row`. Inside a sidebar list the row carries its own padding and `borderRadius.lg` per item (`packages/app/src/components/sidebar-workspace-list.tsx:2614-2625`).
Rows that drill into a detail lead with a chevron in the trailing slot (`ChevronRight`, `iconSize.sm`, `foregroundMuted`). The whole row is the `<Pressable>`. Pair-device row (`packages/app/src/screens/settings/host-page.tsx:644-668`), provider row (`packages/app/src/screens/settings/providers-section.tsx:92-132`), project row in the projects list. A fixed right chevron means navigation. An expandable row uses a trailing right chevron that rotates down when expanded (`SettingsCollapsibleRow`); pressing the row reveals its child rows in place.
A trailing chevron opens a detail, as a page or a sheet (`ChevronRight`, `iconSize.sm`, `foregroundMuted`). The whole row is the pressable; use `<SettingsDetailRow>`. Pair-device row (`packages/app/src/screens/settings/host-page.tsx`), provider row (`packages/app/src/provider-settings/internal/provider-row.tsx`), project row in the projects list. A fixed right chevron means navigation. An expandable row uses a trailing right chevron that rotates down when expanded (`SettingsCollapsibleRow`); pressing the row reveals its child rows in place.
Kebab menus (`<DropdownMenu>` with `<MoreVertical size={14} />` trigger) are for actions on the row, not navigation. Trigger style: `padding: 2`, `borderRadius: 4`, hover background `surface2`. Menu position: `align="end"`. Items use `<DropdownMenuItem leading={<Icon size={14} color={foregroundMuted} />} ...>`. Visibility is `isHovered || isTouchPlatform` — hover-revealed on web, always visible on native (`packages/app/src/components/sidebar-workspace-list.tsx:684-770`).
A row may carry both a chevron and a kebab when both navigation and row-level actions apply. Chevron sits at the end; kebab sits before it.
Switches and segmented controls also sit in the trailing slot. A row that both navigates and toggles is a `<Pressable>` with a `<Switch>` in the trailing slot — the switch calls `event.stopPropagation()` so the row press does not fire (`packages/app/src/screens/settings/providers-section.tsx:92-132`). Sidebar items that hold a status dot, a count, and a kebab follow the same rule (`packages/app/src/components/sidebar-workspace-list.tsx`).
Switches and segmented controls also sit in the trailing slot. A row that both navigates and toggles passes its `<Switch>` as the `control` of `<SettingsDetailRow>`, before the chevron; the switch stops the press from reaching the row (`packages/app/src/provider-settings/internal/provider-row.tsx`). A list the user adds to ends with a muted `<SettingsAddRow>`. Sidebar items that hold a status dot, a count, and a kebab follow the same rule (`packages/app/src/components/sidebar-workspace-list.tsx`).
Selected state on rows in a desktop list+detail uses `surfaceSidebarHover` as the background (`packages/app/src/screens/projects-screen.tsx`). Selected state on rows in the sidebar list uses `surface2` (`packages/app/src/components/agent-list.tsx:563-571`).
@@ -288,7 +288,7 @@ New status pills use `<StatusBadge>`. Identity, shortcut, and interactive link b
| Pattern | Reference |
| --------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| List+detail (compact stack, desktop sidebar+pane) | `packages/app/src/screens/settings-screen.tsx`, `packages/app/src/screens/projects-screen.tsx` |
| Detail card+row | `packages/app/src/screens/settings/host-page.tsx`, `packages/app/src/screens/settings/providers-section.tsx` |
| Detail card+row | `packages/app/src/screens/settings/host-page.tsx`, `packages/app/src/provider-settings/internal/provider-list.tsx` |
| Section grouping inside a card list | `packages/app/src/screens/settings/settings-section.tsx` |
| Form modal (label + input fields, primary + cancel) | `packages/app/src/hosts/add-host/internal/add-host-modal.tsx`, `packages/app/src/hosts/add-host/internal/pair-link-modal.tsx`, `packages/app/src/components/project-picker-modal.tsx` |
| Destructive confirmation | `confirmDialog` invoked from `packages/app/src/screens/settings/host-page.tsx:541-547` |
+12
View File
@@ -510,6 +510,18 @@ before calling status; it exposes your diagnostic through the normal provider di
A command-backed provider without status is available when its executable resolves. Providers with
neither command nor status retain connection-based availability.
Implement optional `installation` to fill the **Installation** section of provider settings. The
bridge sends each callback as a `provider.installation.*` request carrying the launch `status`
receives plus `resolved`. `resolved: false` means the executable was not found and `command` is
the configured name, so answer `not_installed` instead of spawning it. Inspect and update-check
requests use the 30 s plugin request timeout; the daemon's 25 s update-check deadline sits below
it, so a slow check reports that deadline. `update` has no request timeout and streams output
through `provider.installation.report`. When the daemon stops waiting on any of the three, it
sends `provider.installation.cancel`, which aborts the callback's `signal`.
The rules shared with built-ins are in [providers.md](providers.md#installation-and-updates); the
author contract is in the
[public provider guide](../public-docs/plugins/providers.md#report-installation-and-updates).
A same-ID config entry without `extends` overrides the plugin's `enabled`, `command`, `env`, label,
description, and model configuration through the normal provider registry. `enabled: false` disables
selection and discovery. An entry with `extends` defines the user's own provider, shadows the plugin,
+47
View File
@@ -263,6 +263,53 @@ promise for completion: equal results, including equal discovery timestamps, emi
---
## Installation and updates
The provider list and the **Installation** section of a provider's page read `AgentClient.installation`. Built-ins set
it on the client; plugins set `ProviderRegistration.installation`, which the plugin bridge maps to
the same interface. `ProviderInstallations` in `packages/server/src/server/agent/provider-installation/`
owns deadlines, caching and the one running update per provider, so a provider only answers.
Declare only what the vendor offers:
- `installUrl` and `updateUrl` link the vendor's own install and update docs.
- `inspect` reports the version the CLI prints. Versions are opaque: Paseo shows them as written
and never parses them.
- `checkForUpdates` receives the version `inspect` reported as `installedVersion` and asks the
source the CLI's own updater reads, such as the vendor's release endpoint or the CLI's
`update --check`. Do not read the version again. Leave it out when that source is inside the binary or
depends on how the CLI was installed, which is why Copilot and OpenCode have no check. Do not
build a release lookup of your own.
- `update` runs the CLI's own update command and passes its output through, using
`runUpdateCommand`. Paseo adds no verification, signature check or rollback, so the update does
exactly what the same command does in a terminal.
The three calls are separate because they cost differently. `inspect` runs for every provider
whenever the provider list shows, because each row states its version; a provider's page shares the
row's request. It has a 20 s deadline and a 30 s cache. `checkForUpdates` usually reaches the
network. Paseo calls it only after `inspect` reports the CLI installed, and keeps a conclusive
answer for an hour while `inspect` reports the same version, so a CLI updated outside Paseo is
checked again once the 30 s inspection expires. `update` runs for minutes, streams output, and is
aborted only when the daemon stops. A failed update stays on the provider until the next refresh
of its installation, which tells every client observing the provider's updates that it is gone; a
running one is never dropped.
The update check only informs. Once `inspect` reports the CLI installed, the app offers **Update**
for a provider that declares `update`, or **Update instructions** for one that declares only
`updateUrl`, whatever the check answers and whether the provider has one. The check's answer shows
beside the action when it has one. Copilot and OpenCode have no check, so they show **Update** alone.
Write the success message for the provider's process model. A CLI that Paseo starts once per agent
uses `updatedForNewAgents()`. OpenCode agents share one server that keeps the old binary running,
so its message asks the user to restart the daemon.
`createCliInstallation()` covers a CLI that prints `--version` and updates with a subcommand. It
resolves the configured command, so a profile that extends a built-in reports and updates the CLI
that profile launches. Clients for `extends: "acp"` providers declare no installation.
Test with fake executables, as `providers/provider-update-checks.test.ts` does. Running a real
updater during development replaces the CLI on your machine.
## Usage sources
See the [public usage source reference](../public-docs/plugins/reference.md#usage-sources) for the
+1 -1
View File
@@ -1 +1 @@
sha256-yLTaVMgu3tc/dgngJ7RP0htJcWE0ZtQ4mouypevyv0s=
sha256-T3mbzIj0+IZBS4XA+4Ab6e6LtIi8PX4Rzs4wFEWeClk=
@@ -15,7 +15,8 @@ import {
expectProviderInstalledInSettings,
findAcpCatalogProvider,
installAcpCatalogProvider,
openAddProviderArea,
openAddProvider,
openProviderDetail,
openSettingsHost,
openSettingsHostSection,
seedSavedSettingsHosts,
@@ -47,7 +48,7 @@ test.describe("ACP provider catalog", () => {
await openSettings(page);
await openSettingsHost(page, getServerId());
await openSettingsHostSection(page, getServerId(), "providers");
await openAddProviderArea(page);
await openAddProvider(page);
await installAcpCatalogProvider(page, ACP_PROVIDER.name);
await expectProviderInstalledInSettings(page, ACP_PROVIDER.name);
@@ -69,7 +70,7 @@ test("adds fx from the catalog with only a config entry", async ({ page }, testI
await openSettings(page);
await openSettingsHost(page, getServerId());
await openSettingsHostSection(page, getServerId(), "providers");
await openAddProviderArea(page);
await openAddProvider(page);
await findAcpCatalogProvider(page, "fx");
await page.screenshot({ path: testInfo.outputPath("fx-catalog.png") });
@@ -104,7 +105,7 @@ for (const theme of ["light", "dark"] as const) {
await expect(
page.getByRole("button", { name: "Hoplite provider details", exact: true }),
).toHaveCount(0);
await openAddProviderArea(page);
await openAddProvider(page);
await findAcpCatalogProvider(page, "Hoplite");
await page.screenshot({ path: testInfo.outputPath(`hoplite-catalog-${theme}.png`) });
await installAcpCatalogProvider(page, "Hoplite");
@@ -127,7 +128,7 @@ for (const theme of ["light", "dark"] as const) {
testInfo.outputPath(`hoplite-removed-${theme}.json`),
JSON.stringify(await client.getProvidersSnapshot(), null, 2),
);
await openAddProviderArea(page);
await openAddProvider(page);
await findAcpCatalogProvider(page, "Hoplite");
await page.screenshot({ path: testInfo.outputPath(`hoplite-removed-${theme}.png`) });
await installAcpCatalogProvider(page, "Hoplite");
@@ -140,11 +141,11 @@ for (const theme of ["light", "dark"] as const) {
}
async function removeHoplite(page: import("@playwright/test").Page): Promise<void> {
await page.getByTestId("provider-actions-hoplite").click();
await openProviderDetail(page, "Hoplite");
page.once("dialog", (dialog) => {
void dialog.accept();
});
await page.getByTestId("provider-remove-hoplite").click();
await page.getByTestId("provider-remove").click();
}
test("unsupported host asks for an update without writing Hoplite config", async ({
@@ -164,7 +165,7 @@ test("unsupported host asks for an update without writing Hoplite config", async
await openSettings(page);
await openSettingsHost(page, outdatedDaemon.serverId);
await openSettingsHostSection(page, outdatedDaemon.serverId, "providers");
await openAddProviderArea(page);
await openAddProvider(page);
await page.getByRole("button", { name: "Add Hoplite", exact: true }).click();
const errorToast = page.getByTestId("app-toast-message");
await expect(errorToast).toHaveText("Update the host to add Hoplite.");
@@ -2,7 +2,7 @@ import { expect, test } from "../support/fixtures";
import { trackPromptJumpRequests } from "../support/helpers/agent-timeline-gate";
import {
clickChatOutlineRowEdge,
disableChatOutlineFromAppearance,
disableChatOutline,
expectActiveChatOutlinePrompt,
expectActiveChatOutlinePromptMovedFrom,
expectChatOutlinePreview,
@@ -314,13 +314,13 @@ test.describe("desktop chat outline", () => {
}
});
test("can be disabled from Appearance settings", async ({ page }) => {
test("can be disabled from Chat settings", async ({ page }) => {
const agent = await seedLongMockAgentTimeline({ turns: 2 });
try {
await page.setViewportSize(WIDE_VIEWPORT);
await openAgentTimeline(page, agent);
await disableChatOutlineFromAppearance(page);
await disableChatOutline(page);
await expectNoChatOutline(page);
} finally {
+58 -40
View File
@@ -1,20 +1,27 @@
import { test } from "../support/fixtures";
import { expect, test } from "../support/fixtures";
import {
chatOutlineRail,
disableChatOutline,
expectChatOutlinePrompts,
expectNoChatOutline,
} from "../support/helpers/chat-outline";
import {
chooseContentWidth,
expectColumnAtLeftGutter,
expectColumnClearOfOutline,
expectContentColumnWidth,
expectCustomContentWidthSetting,
expectDefaultContentWidthSetting,
openAppearanceSettings,
resetContentWidth,
setContentWidth,
} from "../support/helpers/content-width";
import { openFileExplorer, openFileFromExplorer } from "../support/helpers/file-explorer";
import { openAgentRoute, seedMockAgentWorkspace } from "../support/helpers/mock-agent";
const ULTRAWIDE_VIEWPORT = { width: 2560, height: 1080 };
const DEFAULT_COLUMN = { min: 800, max: 820 };
const WIDE_COLUMN = { min: 1180, max: 1200 };
const FULL_COLUMN = { min: 2000, max: ULTRAWIDE_VIEWPORT.width };
test("widens chat and Markdown files to the chosen content width and resets to the default", async ({
test("resizes mounted chat content and leaves room for the outline at full width", async ({
page,
}, testInfo) => {
}) => {
test.setTimeout(120_000);
const agent = await seedMockAgentWorkspace({
repoPrefix: "content-width-",
@@ -23,47 +30,58 @@ test("widens chat and Markdown files to the chosen content width and resets to t
});
try {
await agent.client.waitForFinish(agent.agentId, 30_000);
await agent.client.sendAgentMessage(agent.agentId, "Write another paragraph.");
await agent.client.waitForFinish(agent.agentId, 30_000);
await page.setViewportSize(ULTRAWIDE_VIEWPORT);
const assistantMessage = page.getByTestId("assistant-message").first();
const markdownPreview = page.getByTestId("markdown-preview-frame").first();
await openAgentRoute(page, agent);
await expectChatOutlinePrompts(page, 2);
const reply = page.getByTestId("assistant-message").first();
const composer = page.getByTestId("message-input-root");
await expectContentColumnWidth(reply, DEFAULT_COLUMN);
const originalReply = await reply.elementHandle();
await test.step("chat starts at the default width", async () => {
await openAgentRoute(page, agent);
await expectContentColumnWidth(assistantMessage, { max: 820 });
});
await chooseContentWidth(page, "Wide");
await expectContentColumnWidth(reply, WIDE_COLUMN);
await expectContentColumnWidth(composer, WIDE_COLUMN);
await test.step("settings show the default without a reset", async () => {
await openAppearanceSettings(page);
await expectDefaultContentWidthSetting(page, 820);
});
await chooseContentWidth(page, "Full");
await expectContentColumnWidth(reply, FULL_COLUMN);
await expectContentColumnWidth(composer, FULL_COLUMN);
await expectColumnClearOfOutline(reply, chatOutlineRail(page));
await test.step("a custom width is saved and offers a reset", async () => {
await setContentWidth(page, 1600);
await expectCustomContentWidthSetting(page, 1600);
await page.screenshot({ path: testInfo.outputPath("settings-custom-width.png") });
});
await disableChatOutline(page);
await expectNoChatOutline(page);
await expectColumnAtLeftGutter(page, reply);
await test.step("chat and Markdown files use the custom width", async () => {
await openAgentRoute(page, agent);
await expectContentColumnWidth(assistantMessage, { min: 1200, max: 1600 });
await page.screenshot({ path: testInfo.outputPath("chat-custom-width.png") });
await chooseContentWidth(page, "Default");
await expectContentColumnWidth(reply, DEFAULT_COLUMN);
await expectContentColumnWidth(composer, DEFAULT_COLUMN);
expect(await originalReply?.evaluate((node) => node.isConnected)).toBe(true);
} finally {
await agent.cleanup();
}
});
await openFileExplorer(page);
await openFileFromExplorer(page, "README.md");
await expectContentColumnWidth(markdownPreview, { min: 1200, max: 1600 });
await page.screenshot({ path: testInfo.outputPath("markdown-custom-width.png") });
});
test("updates an open Markdown preview when the content width changes", async ({ page }) => {
const agent = await seedMockAgentWorkspace({
repoPrefix: "markdown-content-width-",
title: "Markdown content width",
});
await test.step("reset returns to the default without storing it", async () => {
await openAppearanceSettings(page);
await resetContentWidth(page);
await expectDefaultContentWidthSetting(page, 820);
try {
await page.setViewportSize(ULTRAWIDE_VIEWPORT);
await openAgentRoute(page, agent);
await openFileExplorer(page);
await openFileFromExplorer(page, "README.md");
const preview = page.getByTestId("markdown-preview-frame").first();
await expectContentColumnWidth(preview, DEFAULT_COLUMN);
await openAgentRoute(page, agent);
await expectContentColumnWidth(assistantMessage, { max: 820 });
await page.screenshot({ path: testInfo.outputPath("chat-default-width.png") });
});
await chooseContentWidth(page, "Wide");
await expectContentColumnWidth(preview, WIDE_COLUMN);
await chooseContentWidth(page, "Full");
await expectContentColumnWidth(preview, { min: 1500, max: ULTRAWIDE_VIEWPORT.width });
} finally {
await agent.cleanup();
}
@@ -1,10 +1,19 @@
import { test } from "../support/fixtures";
import { expect, test } from "../support/fixtures";
import { gotoAppShell, openSettings } from "../support/helpers/app";
import {
addCustomModel,
expectCustomModelRetained,
openCustomModels,
removeCustomModel,
removeListedCustomModel,
} from "../support/helpers/custom-models";
import { connectDaemonClient } from "../support/helpers/daemon-client-loader";
import { getServerId } from "../support/helpers/server-id";
import {
openProviderDetail,
openSettingsHost,
openSettingsHostSection,
} from "../support/helpers/settings";
const longModelId = "custom-model-with-a-long-name-".repeat(6);
const shortModelId = "custom-short";
@@ -27,3 +36,52 @@ for (const width of [1200, 390]) {
await removeCustomModel(page, shortModelId);
});
}
/** An ACP provider whose command runs but exits before it answers, so the provider fails. */
const FAILING_PROVIDER = { id: "failing-acp", name: "Failing ACP" } as const;
interface ProviderConfigClient {
connect(): Promise<void>;
close(): Promise<void>;
patchDaemonConfig(config: {
providers?: Record<string, { extends: string; label: string; command: string[] }>;
removeProviders?: string[];
}): Promise<unknown>;
}
test("adds and removes a custom model while the provider fails", async ({ page }) => {
test.setTimeout(120_000);
const client = await connectDaemonClient<ProviderConfigClient>({
clientIdPrefix: "custom-model-failing-e2e",
});
try {
await client.patchDaemonConfig({
providers: {
[FAILING_PROVIDER.id]: {
extends: "acp",
label: FAILING_PROVIDER.name,
command: ["node", "-e", "process.exit(1)"],
},
},
});
await gotoAppShell(page);
await openSettings(page);
await openSettingsHost(page, getServerId());
await openSettingsHostSection(page, getServerId(), "providers");
await openProviderDetail(page, FAILING_PROVIDER.name);
await test.step("the page leads with the failure and lists no reported models", async () => {
await expect(page.getByTestId("provider-error")).toBeVisible({ timeout: 30_000 });
await expect(page.getByText("Custom models", { exact: true })).toBeVisible();
await expect(page.getByRole("textbox", { name: "Search models" })).toHaveCount(0);
});
await addCustomModel(page, shortModelId);
await removeListedCustomModel(page, shortModelId);
} finally {
await client
.patchDaemonConfig({ removeProviders: [FAILING_PROVIDER.id] })
.catch(() => undefined);
await client.close().catch(() => undefined);
}
});
+54 -4
View File
@@ -6,6 +6,7 @@ import {
addProjectFromSetup,
continueSetup,
expectSetupStep,
expectSheetCoversSetupCard,
finishSetup,
goToSetupStep,
hostGivesAgentsPaseoTools,
@@ -23,6 +24,7 @@ import {
recordFirstLaunch,
setupModal,
setupPrimaryButton,
setupSheet,
showSetupAgainFromSettings,
skipSetup,
startSetupHost,
@@ -35,7 +37,11 @@ import {
import { installDaemonWebSocketGate } from "../support/helpers/daemon-websocket-gate";
import { enableRelayAndExpectOffer } from "../support/helpers/pair-device";
import { seedWorkspace } from "../support/helpers/seed-client";
import { openSettingsHostSection } from "../support/helpers/settings";
import {
installAcpCatalogProvider,
openAddProvider,
openSettingsHostSection,
} from "../support/helpers/settings";
import { createTempDirectory, createTempGitRepo } from "../support/helpers/workspace";
// Midnight's muted foreground (#9a9db0), which the step description is drawn in.
@@ -59,11 +65,28 @@ test("a new user is walked through setup once", async ({ page }, testInfo) => {
await test.step("Providers shows the same provider list as Settings", async () => {
await continueSetup(page);
await expectSetupStep(page, "Your agents");
await expectSetupStep(page, "Your providers");
await expect(setupModal(page).getByTestId("host-page-providers-card")).toBeVisible();
await page.screenshot({ path: testInfo.outputPath("2-providers.png") });
});
await test.step("a provider's detail and Add provider cover the setup card and lead back to it", async () => {
await setupModal(page)
.getByRole("button", { name: "Claude provider details", exact: true })
.click();
const detail = setupSheet(page, "provider-settings-sheet");
await expectSheetCoversSetupCard(page, detail);
await detail.getByRole("button", { name: "Back to providers", exact: true }).click();
await expect(detail).toHaveCount(0);
await setupModal(page).getByTestId("provider-list-add").click();
const add = setupSheet(page, "add-provider-sheet");
await expectSheetCoversSetupCard(page, add);
await page.keyboard.press("Escape");
await expect(add).toHaveCount(0);
await expectSetupStep(page, "Your providers");
});
await test.step("with no agent history, Add project opens the regular flow and the folder shows as added", async () => {
await continueSetup(page);
await expectSetupStep(page, "Add your projects");
@@ -103,6 +126,33 @@ test("a new user is walked through setup once", async ({ page }, testInfo) => {
}
});
test("a provider removed in setup can be added back and removed again", async ({ page }) => {
test.setTimeout(180_000);
const host = await startSetupHost("re-add");
const detail = setupSheet(page, "provider-settings-sheet");
const remove = detail.getByTestId("provider-remove");
page.on("dialog", (dialog) => void dialog.accept());
try {
await openAppAsNewUser(page, host);
await continueSetup(page);
await expectSetupStep(page, "Your providers");
await openAddProvider(page);
await installAcpCatalogProvider(page, "Junie");
await remove.click();
await expect(detail).toHaveCount(0);
// Adding it back opens the same provider's sheet, which must not still be removing it.
await openAddProvider(page);
await installAcpCatalogProvider(page, "Junie");
await expect(remove).toHaveText("Remove");
await expect(remove).toBeEnabled();
} finally {
await host.close();
}
});
test("a new user goes from the loading screen straight into setup", async ({ page }) => {
const host = await startSetupHost("first-launch");
@@ -145,7 +195,7 @@ test("changing the theme keeps the setup window in place on every step", async (
for (const title of [
"Welcome to Paseo",
"Your agents",
"Your providers",
"Add your projects",
"Let agents use Paseo",
"Take your agents with you",
@@ -418,7 +468,7 @@ test("in the compact layout, Finish on Orchestration applies its switches", asyn
await openAppAsNewUser(page, host);
await step("Welcome to Paseo");
await primary("Continue").click();
await step("Your agents");
await step("Your providers");
await primary("Continue").click();
await step("Add your projects");
await primary("Continue").click();
@@ -1,21 +1,22 @@
import { ACP_PROVIDER_ICON_SVGS } from "../../src/assets/acp-provider-icons";
import { expect, test, type Page } from "../support/fixtures";
import type { TestInfo } from "@playwright/test";
import type { Locator, TestInfo } from "@playwright/test";
import { gotoAppShell, openSettings } from "../support/helpers/app";
import { getServerId } from "../support/helpers/server-id";
import {
findAcpCatalogProvider,
openAddProviderArea,
openAddProvider,
openSettingsHost,
openSettingsHostSection,
} from "../support/helpers/settings";
async function openProviderCatalog(page: Page) {
async function openProviderCatalog(page: Page, viewport?: { width: number; height: number }) {
await gotoAppShell(page);
await openSettings(page);
await openSettingsHost(page, getServerId());
await openSettingsHostSection(page, getServerId(), "providers");
await openAddProviderArea(page);
if (viewport) await page.setViewportSize(viewport);
await openAddProvider(page);
}
async function expectProviderArtwork(
@@ -25,11 +26,11 @@ async function expectProviderArtwork(
name: string,
) {
await findAcpCatalogProvider(page, name);
// Catalog tiles have no semantic role; scope artwork to the named provider's tile.
const icon = page.getByTestId(`provider-catalog-tile-${id}`).locator("svg").first();
// Catalog rows have no semantic role of their own; scope artwork to the named provider's row.
const icon = page.getByTestId(`provider-catalog-row-${id}`).locator("svg").first();
await expect(icon).toBeVisible();
// Provider artwork is 24px; the generic PackagePlus fallback is 20px.
await expect.soft(icon).toHaveAttribute("width", "24");
// Artwork draws at the provider list's icon size, so the catalog and the list share a rail.
await expect.soft(icon).toHaveAttribute("width", "16");
const expectedPaths = await page.evaluate((xml) => {
const document = new DOMParser().parseFromString(xml, "image/svg+xml");
return Array.from(document.querySelectorAll("path"), (path) => path.getAttribute("d")!);
@@ -49,3 +50,20 @@ test("#7087: the provider catalog shows Devin, Hermes, and Kiro artwork", async
await expectProviderArtwork(page, testInfo, "hermes", "Hermes");
await expectProviderArtwork(page, testInfo, "kiro", "Kiro CLI");
});
/** The space between a row's icon and its label, as drawn. */
async function gapAfterIcon(row: Locator, label: string): Promise<number> {
const icon = await row.locator("svg").first().boundingBox();
const text = await row.getByText(label, { exact: true }).boundingBox();
if (!icon || !text) throw new Error(`${label} has no icon or label on screen`);
return text.x - (icon.x + icon.width);
}
test("catalog rows keep the provider list's icon rail on a phone", async ({ page }) => {
await openProviderCatalog(page, { width: 390, height: 844 });
await findAcpCatalogProvider(page, "Kiro CLI");
const listGap = await gapAfterIcon(page.getByTestId("provider-row-claude"), "Claude");
const catalogGap = await gapAfterIcon(page.getByTestId("provider-catalog-row-kiro"), "Kiro CLI");
expect(catalogGap).toBe(listGap);
});
@@ -0,0 +1,54 @@
import { expect, test } from "../support/fixtures";
import { openCustomModels, removeCustomModel } from "../support/helpers/custom-models";
import { installDaemonWebSocketGate } from "../support/helpers/daemon-websocket-gate";
// A pressed control shows its own progress while the daemon answers, the way Button's `loading`
// does: a spinner in place of its icon, no further presses and, on a labelled button, a
// present-participle label.
const MODEL_ID = "in-flight-model";
test.describe("provider page work in flight", () => {
test("says Adding... on the Add button while a custom model is saved", async ({ page }) => {
const gate = await installDaemonWebSocketGate(page);
await openCustomModels(page);
await page.getByRole("button", { name: "Add model", exact: true }).click();
const sheet = page.getByTestId("add-custom-model-sheet");
await page.getByPlaceholder("e.g. openai/gpt-5").fill(MODEL_ID);
gate.holdNextServerMessage("set_daemon_config_response");
await sheet.getByRole("button", { name: "Add", exact: true }).click();
await gate.waitForHeldServerMessage("set_daemon_config_response");
const adding = sheet.getByRole("button", { name: "Adding...", exact: true });
await expect(adding.getByRole("progressbar")).toBeVisible();
await expect(adding).toBeDisabled();
gate.releaseHeldServerMessage("set_daemon_config_response");
await expect(sheet).toBeHidden({ timeout: 30_000 });
await removeCustomModel(page, MODEL_ID);
});
test("shows the diagnostic report running again on its re-run button", async ({ page }) => {
const gate = await installDaemonWebSocketGate(page);
await openCustomModels(page);
await page.getByRole("button", { name: "Diagnostic report", exact: true }).click();
const sheet = page.getByTestId("provider-diagnostic-sheet");
const rerun = sheet.getByRole("button", { name: "Refresh diagnostic", exact: true });
await expect(rerun).toBeEnabled({ timeout: 30_000 });
// Copy has a report to copy once the first run is in.
await expect(sheet.getByRole("button", { name: "Copy diagnostic" })).toBeEnabled();
gate.holdNextServerMessage("provider_diagnostic_response");
await rerun.click();
await gate.waitForHeldServerMessage("provider_diagnostic_response");
const running = sheet.getByRole("button", { name: "Refreshing diagnostic", exact: true });
await expect(running.getByRole("progressbar")).toBeVisible();
await expect(running).toBeDisabled();
gate.releaseHeldServerMessage("provider_diagnostic_response");
await expect(rerun).toBeEnabled({ timeout: 30_000 });
});
});
@@ -2,11 +2,16 @@ import type { Dialog } from "@playwright/test";
import { expect, test, type Page } from "../support/fixtures";
import { gotoAppShell, openSettings } from "../support/helpers/app";
import { connectDaemonClient } from "../support/helpers/daemon-client-loader";
import { installDaemonWebSocketGate } from "../support/helpers/daemon-websocket-gate";
import { getServerId } from "../support/helpers/server-id";
import {
expectInstallOpensGuide,
expectProviderInstalledInSettings,
expectProviderNotOnHost,
installAcpCatalogProvider,
openAddProviderArea,
leaveProviderDetail,
openAddProvider,
openProviderDetail,
openSettingsHost,
openSettingsHostSection,
} from "../support/helpers/settings";
@@ -15,6 +20,8 @@ import { copyPluginExample } from "../support/helpers/plugin-fixture";
const CUSTOM_PROVIDER = {
id: "junie",
name: "Junie",
// The Add provider catalog's guide. The CLI is not installed where these tests run.
installGuide: "https://junie.jetbrains.com/docs/junie-cli-acp.html",
} as const;
const PLUGIN_PROVIDER = {
@@ -62,13 +69,39 @@ async function clickRemoveProviderAndAcceptWarning(page: Page): Promise<Dialog>
expect(dialog.message()).toContain("This deletes the provider entry from config.json.");
void dialog.accept();
});
await page.getByTestId(`provider-remove-${CUSTOM_PROVIDER.id}`).click();
await page.getByTestId("provider-remove").click();
if (!warning) {
throw new Error("Expected a provider removal confirmation dialog, but none was shown.");
}
return warning;
}
const MISSING_NOTICE = '[data-testid="provider-detail-missing"]';
/** Records whether the page ever says its provider isn't on the host, however briefly. */
async function watchForMissingNotice(page: Page): Promise<void> {
await page.evaluate((selector) => {
const flags = window as unknown as { sawMissingNotice?: boolean };
flags.sawMissingNotice = false;
new MutationObserver(() => {
if (document.querySelector(selector)) flags.sawMissingNotice = true;
}).observe(document.body, { childList: true, subtree: true });
}, MISSING_NOTICE);
}
async function expectMissingNoticeNeverShown(page: Page): Promise<void> {
const saw = await page.evaluate(
() => (window as unknown as { sawMissingNotice?: boolean }).sawMissingNotice,
);
expect(saw).toBe(false);
}
/**
* The daemon publishes the provider list without the removed provider before it answers the config
* patch. Holding the answer keeps the page in that window.
*/
const CONFIG_RESPONSE = "set_daemon_config_response";
test.describe("provider removal", () => {
test("removes a custom provider from Settings", async ({ page }) => {
test.setTimeout(120_000);
@@ -79,20 +112,42 @@ test.describe("provider removal", () => {
try {
await removeCustomProvider(client);
const gate = await installDaemonWebSocketGate(page);
await gotoAppShell(page);
await openSettings(page);
await openSettingsHost(page, getServerId());
await openSettingsHostSection(page, getServerId(), "providers");
await expect(page.getByTestId("provider-actions-claude")).toHaveCount(0);
await openAddProviderArea(page);
// A built-in provider has no Danger zone.
await openProviderDetail(page, "Claude");
await expect(page.getByTestId("provider-remove")).toHaveCount(0);
await leaveProviderDetail(page);
await openAddProvider(page);
await installAcpCatalogProvider(page, CUSTOM_PROVIDER.name);
await expectProviderInstalledInSettings(page, CUSTOM_PROVIDER.name);
await expectProviderSource(client, "custom");
await page.getByTestId(`provider-actions-${CUSTOM_PROVIDER.id}`).click();
await expect(page.getByTestId(`provider-remove-${CUSTOM_PROVIDER.id}`)).toBeVisible();
await openProviderDetail(page, CUSTOM_PROVIDER.name);
await test.step("the page points at the catalog's install guide", async () => {
await expectInstallOpensGuide(page, CUSTOM_PROVIDER.installGuide);
});
await expect(page.getByTestId("provider-remove")).toBeVisible();
await watchForMissingNotice(page);
gate.holdNextServerMessage(CONFIG_RESPONSE);
await clickRemoveProviderAndAcceptWarning(page);
await gate.waitForHeldServerMessage(CONFIG_RESPONSE);
await expectProviderSource(client, undefined);
// Until the removal is answered, the page keeps the provider and the pressed button says so.
const removeButton = page.getByTestId("provider-remove");
await expect(removeButton).toHaveText("Removing...");
await expect(removeButton.getByRole("progressbar")).toBeVisible();
await expect(removeButton).toBeDisabled();
await expect(page.getByTestId("provider-detail-title")).toHaveText(CUSTOM_PROVIDER.name);
gate.releaseHeldServerMessage(CONFIG_RESPONSE);
// Removing leaves the provider's page for the list, without first calling it missing.
await expect(page.getByTestId("provider-list")).toBeVisible();
await expectMissingNoticeNeverShown(page);
await expect(
page.getByRole("button", {
@@ -100,7 +155,33 @@ test.describe("provider removal", () => {
exact: true,
}),
).toHaveCount(0);
await expectProviderSource(client, undefined);
} finally {
await removeCustomProvider(client).catch(() => undefined);
await client.close().catch(() => undefined);
}
});
test("says a provider removed elsewhere while its page is open isn't on this host", async ({
page,
}) => {
test.setTimeout(120_000);
const client = await connectDaemonClient<ProviderRemovalDaemonClient>({
clientIdPrefix: "provider-removal-e2e",
});
try {
await removeCustomProvider(client);
await gotoAppShell(page);
await openSettings(page);
await openSettingsHost(page, getServerId());
await openSettingsHostSection(page, getServerId(), "providers");
await openAddProvider(page);
await installAcpCatalogProvider(page, CUSTOM_PROVIDER.name);
await expectProviderInstalledInSettings(page, CUSTOM_PROVIDER.name);
await openProviderDetail(page, CUSTOM_PROVIDER.name);
await removeCustomProvider(client);
await expectProviderNotOnHost(page);
} finally {
await removeCustomProvider(client).catch(() => undefined);
await client.close().catch(() => undefined);
@@ -130,7 +211,9 @@ test.describe("provider removal", () => {
exact: true,
});
await expect(pluginProviderRow).toBeVisible();
await expect(page.getByTestId(`provider-actions-${PLUGIN_PROVIDER.id}`)).toHaveCount(0);
await openProviderDetail(page, PLUGIN_PROVIDER.name);
await expect(page.getByTestId("provider-remove")).toHaveCount(0);
await leaveProviderDetail(page);
// The provider survives a removeProviders patch pointed at it: the
// plugin, not config.json, owns the definition.
@@ -97,7 +97,7 @@ async function hasFocusWithin(locator: Locator): Promise<boolean> {
async function expectProviderSettingsVisible(page: Page) {
await expect(page.getByTestId("provider-settings-sheet")).toBeVisible({ timeout: 10_000 });
await expect(page.getByRole("button", { name: "Add model" })).toBeVisible();
await expect(page.getByRole("button", { name: "Diagnostic", exact: true })).toBeVisible();
await expect(page.getByRole("button", { name: "Diagnostic report" })).toBeVisible();
}
async function exerciseProviderSettingsStack(page: Page) {
@@ -109,7 +109,7 @@ async function exerciseProviderSettingsStack(page: Page) {
await expect(page.getByPlaceholder("e.g. openai/gpt-5")).not.toBeVisible({ timeout: 10_000 });
await expectProviderSettingsVisible(page);
await page.getByRole("button", { name: "Diagnostic", exact: true }).click();
await page.getByRole("button", { name: "Diagnostic report" }).click();
await expect(page.getByTestId("provider-diagnostic-sheet")).toBeVisible({ timeout: 10_000 });
await page.getByRole("button", { name: /Refresh diagnostic/ }).click();
await expect(page.getByTestId("provider-diagnostic-sheet")).toBeVisible({ timeout: 10_000 });
@@ -118,7 +118,7 @@ async function exerciseProviderSettingsStack(page: Page) {
await page.getByRole("button", { name: "Refresh", exact: true }).click();
await expectProviderSettingsVisible(page);
await expect(page.getByText("Updated just now", { exact: true })).toBeVisible({
await expect(page.getByText("Checked just now", { exact: true })).toBeVisible({
timeout: 30_000,
});
}
@@ -0,0 +1,44 @@
import {
backToProviderList,
expectNoUpdateFailure,
expectRowReadsVersionAndModels,
expectRowReportsUpdateFailure,
openProviderInstallation,
refreshFromOtherClient,
refreshProviderDetails,
runFailingUpdate,
test,
} from "../support/helpers/provider-update-failure";
test("a refresh clears a failed update from the provider's page and its row", async ({
providerUpdateFailure: { page, otherClient },
}) => {
await openProviderInstallation(page);
await test.step("Refresh on the page clears the failure", async () => {
await runFailingUpdate(page);
await refreshProviderDetails(page);
await expectNoUpdateFailure(page);
});
await test.step("the row in the list reads the version and models again", async () => {
await backToProviderList(page);
await expectRowReadsVersionAndModels(page);
});
await test.step("a refresh from another client clears the page", async () => {
await openProviderInstallation(page);
await runFailingUpdate(page);
await refreshFromOtherClient(otherClient);
await expectNoUpdateFailure(page);
});
await test.step("a refresh from another client clears the row on the open list", async () => {
await runFailingUpdate(page);
await backToProviderList(page);
// Without a refresh, the row still reports the failure.
await expectRowReportsUpdateFailure(page);
await refreshFromOtherClient(otherClient);
await expectRowReadsVersionAndModels(page);
});
});
@@ -15,6 +15,9 @@ import { startIsolatedHostDaemon } from "../support/helpers/isolated-host-daemon
import { getServerId } from "../support/helpers/server-id";
import {
expectSettingsHeader,
expectProviderNotOnHost,
expectProviderPageLoaded,
gotoProviderPage,
openSettingsHost,
openHostSection,
expectHostLabelDisplayed,
@@ -264,6 +267,20 @@ test.describe("Settings host page", () => {
});
});
test.describe("provider page from its URL", () => {
test("loads a provider's page on a cold visit", async ({ page }) => {
await gotoAppShell(page);
await gotoProviderPage(page, getServerId(), "claude");
await expectProviderPageLoaded(page, "Claude");
});
test("says a provider the host doesn't have isn't on this host", async ({ page }) => {
await gotoAppShell(page);
await gotoProviderPage(page, getServerId(), "not-a-provider");
await expectProviderNotOnHost(page);
});
});
test("restart recovery defaults off and persists opt-in and custom prompt", async ({ page }) => {
const serverId = getServerId();
await gotoAppShell(page);
@@ -1,6 +1,6 @@
import { expect, type Locator, type Page } from "@playwright/test";
import { openSettings } from "./app";
import { openSettingsSection } from "./settings";
import { clickSettingsBackToWorkspace, openSettingsSection } from "./settings";
import { runWorkspaceActionFromCommandCenter } from "./command-center-workspace-actions";
import { seedMockAgentWorkspace, type MockAgentWorkspace } from "./mock-agent";
import { loadSessionMessageReaders } from "./new-workspace";
@@ -81,12 +81,13 @@ export async function splitCurrentPanelRight(page: Page): Promise<void> {
await runWorkspaceActionFromCommandCenter(page, "Split pane right");
}
export async function disableChatOutlineFromAppearance(page: Page): Promise<void> {
const timelineUrl = page.url();
export async function disableChatOutline(page: Page): Promise<void> {
await openSettings(page);
await openSettingsSection(page, "chat");
await page.getByRole("switch", { name: "Chat outline" }).click();
await page.goto(timelineUrl);
const outlineSwitch = page.getByRole("switch", { name: "Chat outline" });
await outlineSwitch.click();
await expect(outlineSwitch).not.toBeChecked();
await clickSettingsBackToWorkspace(page);
}
/** Parks the pointer in the middle of the transcript, clear of the rail. */
@@ -1,63 +1,53 @@
import { expect, type Locator, type Page } from "@playwright/test";
import { openSettings } from "./app";
import { openSettingsSection } from "./settings";
import { clickSettingsBackToWorkspace, openSettingsSection } from "./settings";
const APP_SETTINGS_KEY = "@paseo:app-settings";
type ContentWidthOption = "Default" | "Wide" | "Full";
function contentWidthInput(page: Page): Locator {
return page.getByLabel("Content width in pixels", { exact: true });
function contentWidthOption(page: Page, option: ContentWidthOption): Locator {
return page
.getByTestId("content-width-options")
.getByRole("button", { name: option, exact: true });
}
function resetContentWidthButton(page: Page): Locator {
return page.getByRole("button", { name: "Reset content width to default", exact: true });
}
export async function openAppearanceSettings(page: Page): Promise<void> {
export async function chooseContentWidth(page: Page, option: ContentWidthOption): Promise<void> {
await openSettings(page);
await openSettingsSection(page, "appearance");
const button = contentWidthOption(page, option);
await button.click();
await expect(button).toHaveAttribute("aria-selected", "true");
await clickSettingsBackToWorkspace(page);
}
export async function setContentWidth(page: Page, width: number): Promise<void> {
const input = contentWidthInput(page);
await input.fill(String(width));
await input.press("Tab");
}
export async function resetContentWidth(page: Page): Promise<void> {
await resetContentWidthButton(page).click();
}
export async function expectDefaultContentWidthSetting(page: Page, width: number): Promise<void> {
await expect(contentWidthInput(page)).toHaveValue(String(width));
await expect(resetContentWidthButton(page)).toHaveCount(0);
await expect.poll(() => readStoredContentWidth(page)).toBeNull();
}
export async function expectCustomContentWidthSetting(page: Page, width: number): Promise<void> {
await expect(contentWidthInput(page)).toHaveValue(String(width));
await expect(resetContentWidthButton(page)).toBeVisible();
await expect.poll(() => readStoredContentWidth(page)).toBe(width);
}
/** Asserts the rendered width of a content-column element stays within `max` and above `min`. */
/** Checks the rendered content width, allowing for padding inside the column. */
export async function expectContentColumnWidth(
element: Locator,
bounds: { min?: number; max: number },
bounds: { min: number; max: number },
): Promise<void> {
await expect(element).toBeVisible({ timeout: 30_000 });
await expect
.poll(async () => (await element.boundingBox())?.width ?? 0)
.toBeLessThanOrEqual(bounds.max);
.toBeGreaterThanOrEqual(bounds.min);
await expect
.poll(async () => (await element.boundingBox())?.width ?? 0)
.toBeGreaterThan(bounds.min ?? 0);
.poll(async () => (await element.boundingBox())?.width ?? Infinity)
.toBeLessThanOrEqual(bounds.max);
}
async function readStoredContentWidth(page: Page): Promise<unknown> {
return page.evaluate((key) => {
const raw = localStorage.getItem(key);
return raw === null
? undefined
: (JSON.parse(raw) as { contentMaxWidth?: unknown }).contentMaxWidth;
}, APP_SETTINGS_KEY);
export async function expectColumnClearOfOutline(column: Locator, outline: Locator): Promise<void> {
await expect
.poll(async () => {
const [content, rail] = await Promise.all([column.boundingBox(), outline.boundingBox()]);
return content && rail ? content.x - (rail.x + rail.width) : -1;
})
.toBeGreaterThanOrEqual(8);
}
export async function expectColumnAtLeftGutter(page: Page, column: Locator): Promise<void> {
const viewport = page.getByTestId("agent-chat-scroll");
await expect
.poll(async () => {
const [content, scroll] = await Promise.all([column.boundingBox(), viewport.boundingBox()]);
return content && scroll ? content.x - scroll.x : Infinity;
})
.toBeLessThanOrEqual(24);
}
@@ -25,7 +25,12 @@ export async function addCustomModel(page: Page, id: string): Promise<void> {
}
export async function removeCustomModel(page: Page, id: string): Promise<void> {
await page.getByRole("textbox", { name: "Search models" }).fill(id);
await searchModels(page, id);
await removeListedCustomModel(page, id);
}
/** Removes a custom model shown on the page without searching for it first. */
export async function removeListedCustomModel(page: Page, id: string): Promise<void> {
const remove = page.getByRole("button", { name: `Remove ${id}`, exact: true });
await expect(remove).toBeInViewport({ ratio: 1 });
await remove.click();
@@ -33,8 +38,20 @@ export async function removeCustomModel(page: Page, id: string): Promise<void> {
}
export async function expectCustomModelRetained(page: Page, id: string): Promise<void> {
await page.getByRole("textbox", { name: "Search models" }).fill(id);
await searchModels(page, id);
await expect(page.getByRole("button", { name: `Remove ${id}`, exact: true })).toBeInViewport({
ratio: 1,
});
}
/**
* Filters the model list and scrolls the sheet down to the custom models, since other sections push
* them below the fold at phone width. Only the section heading is scrolled into view: scrolling the
* row itself would also slide its card sideways and hide a Remove button pushed past the right edge.
*/
async function searchModels(page: Page, id: string): Promise<void> {
await page.getByRole("textbox", { name: "Search models" }).fill(id);
await page
.getByText("Custom models", { exact: true })
.evaluate((heading) => heading.scrollIntoView({ block: "start" }));
}
@@ -86,6 +86,17 @@ export function setupModal(page: Page): Locator {
return page.getByTestId("onboarding-modal").getByRole("dialog");
}
/** A sheet opened from a setup step, which should sit exactly on the setup card. */
export function setupSheet(page: Page, testID: "provider-settings-sheet" | "add-provider-sheet") {
return page.getByTestId(testID).getByRole("dialog");
}
export async function expectSheetCoversSetupCard(page: Page, sheet: Locator): Promise<void> {
await expect(sheet).toBeVisible();
const card = await setupModal(page).boundingBox();
await expect.poll(() => sheet.boundingBox()).toEqual(card);
}
export async function expectSetupStep(page: Page, title: string): Promise<void> {
await expect(setupModal(page).getByRole("heading", { name: title, exact: true })).toBeVisible({
timeout: 60_000,
@@ -106,10 +106,12 @@ export async function verifyProviderSettings({
await test.step("provider settings render the registered icon", async () => {
await openSettings(page);
await openSettingsHostSection(page, getServerId(), "providers");
await expectProviderIcon(
page.getByRole("button", { name: "Direct provider example provider details", exact: true }),
iconPaths,
);
// The row's button lies under its content, so the icon is in the row, beside the button.
const opener = page.getByRole("button", {
name: "Direct provider example provider details",
exact: true,
});
await expectProviderIcon(page.getByTestId(/^provider-row-/).filter({ has: opener }), iconPaths);
await capture(page, testInfo, "provider-settings");
await page.getByTestId("settings-back-to-workspace").click();
});
@@ -0,0 +1,138 @@
import { writeFile } from "node:fs/promises";
import path from "node:path";
import type { DaemonClient as InternalDaemonClient } from "@getpaseo/client/internal/daemon-client";
import { expect, test as base, type Page } from "../fixtures";
import { gotoAppShell, openSettings } from "./app";
import { connectDaemonClient } from "./daemon-client-loader";
import { copyPluginExample, pluginRequirements } from "./plugin-fixture";
import { getServerId } from "./server-id";
import { leaveProviderDetail, openSettingsHostSection } from "./settings";
const PLUGIN_ID = "provider-update-failure";
const PROVIDER_ID = "update-failure";
const PROVIDER_NAME = "Update failure";
const FAILURE = "The updater could not write to the install directory";
/** The direct provider example with an installation whose updater always fails. */
const SERVER_SOURCE = `import type { PluginServerContext } from "@getpaseo/plugin/server";
import { createDirectExampleProvider } from "./server/provider";
export default function contribute(server: PluginServerContext) {
server.registerProvider({
...createDirectExampleProvider(),
id: ${JSON.stringify(PROVIDER_ID)},
label: ${JSON.stringify(PROVIDER_NAME)},
installation: {
async inspect() {
return { status: "installed", version: "1.0.0" };
},
async update({ report }) {
report({ type: "stderr", text: "EACCES\\n" });
return { status: "failed", message: ${JSON.stringify(FAILURE)} };
},
},
});
return () => {};
}
`;
type ObserverClient = Pick<
InternalDaemonClient,
| "close"
| "connect"
| "getDaemonConfig"
| "inspectProviderInstallation"
| "installDirectoryPlugin"
| "patchDaemonConfig"
| "removePlugin"
>;
interface ProviderUpdateFailure {
page: Page;
/** A second client of the same host. */
otherClient: ObserverClient;
}
export const test = base.extend<{ providerUpdateFailure: ProviderUpdateFailure }>({
providerUpdateFailure: async ({ page }, provide) => {
const client = await connectDaemonClient<ObserverClient>({
clientIdPrefix: "app-e2e-provider-update-failure",
});
const plugin = await copyPluginExample("provider-direct");
try {
const previous = await client.getDaemonConfig();
await writeFile(
path.join(plugin.directory, "paseo-plugin.json"),
JSON.stringify({ id: PLUGIN_ID, requirements: pluginRequirements }),
);
await writeFile(path.join(plugin.directory, "index.server.ts"), SERVER_SOURCE);
try {
await client.patchDaemonConfig({ pluginsEnabled: true });
await client.installDirectoryPlugin(plugin.directory);
await provide({ page, otherClient: client });
} finally {
try {
await client.removePlugin(PLUGIN_ID);
} finally {
await client.patchDaemonConfig({ pluginsEnabled: previous.config.pluginsEnabled });
}
}
} finally {
await plugin.cleanup();
await client.close();
}
},
});
export async function openProviderInstallation(page: Page): Promise<void> {
await gotoAppShell(page);
await openSettings(page);
await openSettingsHostSection(page, getServerId(), "providers");
await page
.getByRole("button", { name: `${PROVIDER_NAME} provider details`, exact: true })
.click();
await expect(page.getByTestId("provider-installation-version")).toHaveText("1.0.0");
}
export async function runFailingUpdate(page: Page): Promise<void> {
await page.getByTestId("provider-update-start").click();
await expect(page.getByTestId("provider-update-status")).toHaveText("Update failed");
await expect(page.getByTestId("provider-update-message")).toHaveText(FAILURE);
}
export async function refreshProviderDetails(page: Page): Promise<void> {
await page.getByTestId("provider-refresh").click();
}
export async function backToProviderList(page: Page): Promise<void> {
await leaveProviderDetail(page);
}
function providerRow(page: Page) {
return page.getByTestId(`provider-row-${PROVIDER_ID}`);
}
/** The provider's row in the list reports the failed update, with the error dot. */
export async function expectRowReportsUpdateFailure(page: Page): Promise<void> {
const row = providerRow(page);
await expect(row).toContainText(FAILURE);
await expect(row.getByTestId("settings-row-error-dot")).toHaveCount(1);
}
/** The provider's row reads its version and model count again, with no error dot. */
export async function expectRowReadsVersionAndModels(page: Page): Promise<void> {
const row = providerRow(page);
await expect(row).toContainText("1.0.0 · 1 model");
await expect(row).not.toContainText(FAILURE);
await expect(row.getByTestId("settings-row-error-dot")).toHaveCount(0);
}
export async function refreshFromOtherClient(client: ObserverClient): Promise<void> {
const result = await client.inspectProviderInstallation(PROVIDER_ID, { refresh: true });
expect(result.error).toBeNull();
}
export async function expectNoUpdateFailure(page: Page): Promise<void> {
await expect(page.getByTestId("provider-update-run")).toHaveCount(0);
await expect(page.getByTestId("provider-installation-version")).toHaveText("1.0.0");
}
+67 -2
View File
@@ -515,8 +515,8 @@ export async function serveJson(page: Page, url: string, body: unknown): Promise
});
}
export async function openAddProviderArea(page: Page): Promise<void> {
await page.getByTestId("host-page-add-provider-card").scrollIntoViewIfNeeded();
export async function openAddProvider(page: Page): Promise<void> {
await page.getByTestId("provider-list-add").click();
await expect(page.getByRole("textbox", { name: "Search providers" })).toBeVisible();
}
@@ -528,17 +528,82 @@ export async function findAcpCatalogProvider(page: Page, providerName: string):
export async function installAcpCatalogProvider(page: Page, providerName: string): Promise<void> {
await findAcpCatalogProvider(page, providerName);
await page.getByRole("button", { name: `Add ${providerName}`, exact: true }).click();
// The sheet closes once the add is done. Adding probes the new provider, which can outlast an
// assertion's default wait.
await expect(page.getByRole("textbox", { name: "Search providers" })).toHaveCount(0, {
timeout: 60_000,
});
}
/** Adding opens the new provider's page; its row waits in the list behind it. */
export async function expectProviderInstalledInSettings(
page: Page,
providerName: string,
): Promise<void> {
await expect(page.getByTestId("provider-detail-title")).toHaveText(providerName);
await page.getByTestId("provider-detail-back").click();
await expect(
page.getByRole("button", { name: `${providerName} provider details`, exact: true }),
).toBeVisible();
}
export async function openProviderDetail(page: Page, providerName: string): Promise<void> {
await page.getByRole("button", { name: `${providerName} provider details`, exact: true }).click();
await expect(page.getByTestId("provider-detail-title")).toHaveText(providerName);
}
/** Load a provider's Settings page from its URL, as a reload or a shared link does. */
export async function gotoProviderPage(
page: Page,
serverId: string,
providerId: string,
): Promise<void> {
await page.goto(
`/settings/hosts/${encodeURIComponent(serverId)}/providers/${encodeURIComponent(providerId)}`,
);
}
export async function expectProviderPageLoaded(page: Page, providerName: string): Promise<void> {
await expect(page.getByTestId("provider-detail-title")).toHaveText(providerName, {
timeout: 30_000,
});
await expect(page.getByText("Provider status")).toBeVisible({ timeout: 30_000 });
}
export async function expectProviderNotOnHost(page: Page): Promise<void> {
await expect(page.getByText("This provider isn't on this host")).toBeVisible({
timeout: 30_000,
});
}
/**
* The provider page says the provider's CLI is missing, and Install opens the given guide. The
* guide is served locally so the test never reaches the network.
*/
export async function expectInstallOpensGuide(page: Page, guideUrl: string): Promise<void> {
const installation = page.getByTestId("provider-installation");
await expect(installation.getByText("Not installed", { exact: true })).toBeVisible({
timeout: 30_000,
});
await page.context().route(guideUrl, (route) =>
route.fulfill({
status: 200,
contentType: "text/html",
body: "<title>Install guide</title>",
}),
);
const guide = page.waitForEvent("popup");
await installation.getByRole("button", { name: "Install", exact: true }).click();
const opened = await guide;
expect(opened.url()).toBe(guideUrl);
await opened.close();
}
export async function leaveProviderDetail(page: Page): Promise<void> {
await page.getByTestId("provider-detail-back").click();
await expect(page.getByTestId("provider-list")).toBeVisible();
}
export async function expectHostNoDaemonLifecycleRow(page: Page): Promise<void> {
await expect(page.getByTestId("host-page-daemon-lifecycle-card")).toHaveCount(0);
}
@@ -11,3 +11,7 @@ export interface ChatOutlineRailProps {
export function ChatOutlineRail(_props: ChatOutlineRailProps): null {
return null;
}
export function useChatOutlineRailLayout(_enabled: boolean) {
return { onLayout: undefined, inset: 0 };
}
@@ -3,6 +3,7 @@ import { Pressable, Text, View, type PointerEvent as RNPointerEvent } from "reac
import { StyleSheet } from "react-native-unistyles";
import { useReducedMotion } from "react-native-reanimated";
import { useContainerWidthBelow } from "@/hooks/use-container-width";
import { SPACING } from "@/styles/theme";
import { inlineUnistylesStyle } from "@/styles/unistyles-inline-style";
import { createChatOutlineHoverIntent } from "./hover-intent";
import { promptTickMagnification } from "./model";
@@ -11,6 +12,7 @@ import type { ChatOutlineRailProps } from "./rail";
// Hover tracking lives on the rail and the slots, never on the Pressable inside them:
// magnifying a slot must not move the box the pointer is resting on. See docs/hover.md.
const RAIL_WIDTH = 36;
const RAIL_LEFT = SPACING[2];
const SLOT_HEIGHT = 8;
const MIN_PANEL_WIDTH = 918;
const RESTING_PILL_HEIGHT = 2;
@@ -22,6 +24,11 @@ const PREVIEW_WIDTH = 260;
const PREVIEW_HEIGHT = 48;
const PREVIEW_GAP = 4;
export function useChatOutlineRailLayout(enabled: boolean) {
const { onLayout, isBelow } = useContainerWidthBelow(MIN_PANEL_WIDTH);
return { onLayout, inset: enabled && !isBelow ? RAIL_LEFT + RAIL_WIDTH : 0 };
}
export const ChatOutlineRail = memo(function ChatOutlineRail({
prompts,
activePrompt,
@@ -31,7 +38,6 @@ export const ChatOutlineRail = memo(function ChatOutlineRail({
const [focusedIndex, setFocusedIndex] = useState<number | null>(null);
const activeSeq = useSyncExternalStore(activePrompt.subscribe, activePrompt.getActiveSeq);
const prefersReducedMotion = useReducedMotion();
const { onLayout, isBelow: isPanelNarrow } = useContainerWidthBelow(MIN_PANEL_WIDTH);
const hoverIntent = useMemo(
() =>
@@ -60,9 +66,6 @@ export const ChatOutlineRail = memo(function ChatOutlineRail({
);
const handlePointerLeaveRail = useCallback(() => hoverIntent.leave(), [hoverIntent]);
useEffect(() => () => hoverIntent.dispose(), [hoverIntent]);
useEffect(() => {
if (isPanelNarrow) hoverIntent.leave();
}, [hoverIntent, isPanelNarrow]);
const handleFocusChange = useCallback((index: number, focused: boolean) => {
setFocusedIndex((current) => {
if (focused) return index;
@@ -74,40 +77,34 @@ export const ChatOutlineRail = memo(function ChatOutlineRail({
// same band and the same preview once the pointer leaves.
const attentionIndex = hoveredIndex ?? focusedIndex;
if (prompts.length < 2) return null;
return (
<View style={styles.panelMeasure} pointerEvents="box-none" onLayout={onLayout}>
{isPanelNarrow ? null : (
<View
style={styles.rail}
role="tablist"
testID="chat-outline-rail"
onPointerEnter={handlePointerEnterRail}
onPointerMove={handlePointerMoveRail}
onPointerLeave={handlePointerLeaveRail}
>
{prompts.map((prompt, index) => (
<ChatOutlineTick
key={prompt.seq}
index={index}
seq={prompt.seq}
preview={prompt.preview}
label={`${index + 1} of ${prompts.length}: ${prompt.preview}`}
isActive={prompt.seq === activeSeq}
hasAttention={index === attentionIndex}
magnification={
prefersReducedMotion || attentionIndex === null
? 0
: promptTickMagnification(index - attentionIndex)
}
onHover={handlePointerEnterTick}
onFocusChange={handleFocusChange}
onJumpToPrompt={onJumpToPrompt}
/>
))}
</View>
)}
<View
style={styles.rail}
role="tablist"
testID="chat-outline-rail"
onPointerEnter={handlePointerEnterRail}
onPointerMove={handlePointerMoveRail}
onPointerLeave={handlePointerLeaveRail}
>
{prompts.map((prompt, index) => (
<ChatOutlineTick
key={prompt.seq}
index={index}
seq={prompt.seq}
preview={prompt.preview}
label={`${index + 1} of ${prompts.length}: ${prompt.preview}`}
isActive={prompt.seq === activeSeq}
hasAttention={index === attentionIndex}
magnification={
prefersReducedMotion || attentionIndex === null
? 0
: promptTickMagnification(index - attentionIndex)
}
onHover={handlePointerEnterTick}
onFocusChange={handleFocusChange}
onJumpToPrompt={onJumpToPrompt}
/>
))}
</View>
);
});
@@ -185,13 +182,9 @@ const ChatOutlineTick = memo(function ChatOutlineTick({
});
const styles = StyleSheet.create((theme) => ({
panelMeasure: {
position: "absolute",
inset: 0,
},
rail: {
position: "absolute",
left: theme.spacing[2],
left: RAIL_LEFT,
top: "10%",
bottom: "10%",
width: RAIL_WIDTH,
+26 -6
View File
@@ -314,6 +314,7 @@ function WebStreamViewport(props: StreamRenderInput & { isMobileBreakpoint: bool
olderHistoryProgressKey,
scrollEnabled,
contentMaxWidth,
outlineInset = 0,
isMobileBreakpoint,
} = props;
const historyVirtualized = useRevisedHistoryRows(
@@ -453,7 +454,13 @@ function WebStreamViewport(props: StreamRenderInput & { isMobileBreakpoint: bool
unsubscribe?.();
};
}, []);
const contentWidth = contentRef.current?.getBoundingClientRect().width;
// The scroll viewport keeps its width when the reading column changes.
// Track the effective column width for cached measurements and estimates.
const readContentWidth = () => {
const available = rowsHostRef.current?.getBoundingClientRect().width;
return available ? Math.min(available, contentMaxWidth ?? available) : contentMaxWidth;
};
const contentWidth = readContentWidth();
const rowVirtualizer = useVirtualizer({
count: segments.historyVirtualized.length,
enabled: shouldUseVirtualizer,
@@ -469,7 +476,9 @@ function WebStreamViewport(props: StreamRenderInput & { isMobileBreakpoint: bool
const row = segments.historyVirtualized[index];
const measured = row && measuredRowHeights.current.get(row.id);
if (measured && measured.width === contentWidth) return measured.height;
return row ? estimateStreamItemHeight({ item: row, contentMaxWidth }) : 120;
return row
? estimateStreamItemHeight({ item: row, contentMaxWidth: contentWidth ?? 0 })
: 120;
},
observeElementOffset: observeVirtualOffset,
rangeExtractor,
@@ -477,6 +486,10 @@ function WebStreamViewport(props: StreamRenderInput & { isMobileBreakpoint: bool
overscan: 8,
});
rowVirtualizerRef.current = rowVirtualizer;
useLayoutEffect(() => {
// Discard offscreen sizes measured with the previous text wrapping.
rowVirtualizer.measure();
}, [contentMaxWidth, outlineInset, rowVirtualizer]);
// Scroll correction belongs to the viewport's committed layout. The virtualizer
// otherwise writes scrollTop before React applies its new row positions.
rowVirtualizer.shouldAdjustScrollPositionOnItemSizeChange = () => false;
@@ -722,7 +735,7 @@ function WebStreamViewport(props: StreamRenderInput & { isMobileBreakpoint: bool
if (!container || !content) return null;
const viewportTop = container.getBoundingClientRect().top;
const scrollTop = container.scrollTop;
const width = content.getBoundingClientRect().width;
const width = readContentWidth() ?? 0;
return Array.from(content.querySelectorAll<HTMLElement>("[data-history-row-id]"), (element) => {
const bounds = element.getBoundingClientRect();
const id = element.dataset.historyRowId!;
@@ -1215,17 +1228,24 @@ function WebStreamViewport(props: StreamRenderInput & { isMobileBreakpoint: bool
]);
const contentContainerStyle = useMemo((): CSSProperties => {
const gutter = isMobileBreakpoint ? 8 : 16;
const leftGutter = gutter + outlineInset;
// Balance the outline gutter using only the space the capped column has left over.
const rightGutter =
outlineInset > 0 && contentMaxWidth !== undefined
? `clamp(${gutter}px, calc(100% - ${leftGutter + contentMaxWidth}px), ${leftGutter}px)`
: gutter;
return {
display: "flex",
flexDirection: "column",
minHeight: "100%",
paddingTop: CONTENT_PADDING_TOP_PX,
paddingBottom: 16,
paddingLeft: isMobileBreakpoint ? 8 : 16,
paddingRight: isMobileBreakpoint ? 8 : 16,
paddingLeft: leftGutter,
paddingRight: rightGutter,
boxSizing: "border-box",
};
}, [isMobileBreakpoint]);
}, [contentMaxWidth, isMobileBreakpoint, outlineInset]);
const scrollContainerStyle = useMemo((): CSSProperties => {
const overlayScrollbarEnabled = scrollEnabled && !isMobileBreakpoint;
return {
+2 -1
View File
@@ -107,7 +107,8 @@ export interface StreamRenderInput {
baseListContentContainerStyle: StyleProp<ViewStyle>;
forwardListContentContainerStyle: StyleProp<ViewStyle>;
// The chat column's max width. The web viewport estimates unmeasured row heights with it.
contentMaxWidth: number;
contentMaxWidth: number | undefined;
outlineInset?: number;
}
export interface ResolveStreamRenderStrategyInput {
+17 -8
View File
@@ -80,7 +80,7 @@ import { resolveStreamRenderStrategy } from "./strategy-resolver";
import { type StreamSegmentRenderers, type StreamViewportHandle } from "./strategy";
import { renderStreamRow, type RenderStreamItem } from "./stream-row";
import { type NearBottom, useIsNearBottom, useNearBottom } from "./near-bottom";
import { ChatOutlineRail } from "@/agent-stream/chat-outline/rail";
import { ChatOutlineRail, useChatOutlineRailLayout } from "@/agent-stream/chat-outline/rail";
import { useChatOutline } from "@/agent-stream/chat-outline/use-chat-outline";
import { getHostRuntimeStore } from "@/runtime/host-runtime";
import { planTimelineTailFetch } from "@/timeline/timeline-sync-plan";
@@ -617,19 +617,22 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
mountedHistoryMessageIds.has(messageId) || liveHeadMessageIds.has(messageId),
};
}, [baseRenderModel.segments.liveHead, mountedHistoryMessageIds]);
const outlineEnabled = supportsChatOutline && chatOutlineEnabled;
const chatOutline = useChatOutline({
agentId,
serverId: resolvedServerId,
timelineEpoch,
tail: effectiveStreamItems,
head: effectiveStreamHead,
enabled: supportsChatOutline && chatOutlineEnabled,
enabled: outlineEnabled,
viewportRef,
onJumpError: handleTimelineHistoryLoadError,
mountedHistoryMessageIds,
revealLoadedMessage: revealLoadedHistory,
});
const outlineLayout = useChatOutlineRailLayout(outlineEnabled);
useImperativeHandle(
ref,
() => ({
@@ -1173,7 +1176,10 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
visibleMessageIds={mountedMessageIds}
>
<ToolCallSheetProvider>
<AssistantSelectionCopySurface style={stylesheet.container}>
<AssistantSelectionCopySurface
style={stylesheet.container}
onLayout={outlineLayout.onLayout}
>
<MessageOuterSpacingProvider disableOuterSpacing>
<ToolCallExpansionContext.Provider value={toolCallExpansion}>
<UserMessageExpansionContext.Provider value={userMessageExpansion}>
@@ -1202,15 +1208,18 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
baseListContentContainerStyle: stylesheet.listContentContainer,
forwardListContentContainerStyle: stylesheet.forwardListContentContainer,
contentMaxWidth,
outlineInset: outlineLayout.inset,
})}
</UserMessageExpansionContext.Provider>
</ToolCallExpansionContext.Provider>
</MessageOuterSpacingProvider>
<ChatOutlineRail
prompts={chatOutline.prompts}
activePrompt={chatOutline.activePrompt}
onJumpToPrompt={chatOutline.jumpToPrompt}
/>
{outlineLayout.inset > 0 && chatOutline.prompts.length >= 2 ? (
<ChatOutlineRail
prompts={chatOutline.prompts}
activePrompt={chatOutline.activePrompt}
onJumpToPrompt={chatOutline.jumpToPrompt}
/>
) : null}
<ScrollToBottomButton
nearBottom={nearBottom}
isTimelineDetached={isTimelineDetached}
+1
View File
@@ -936,6 +936,7 @@ function RootStack() {
<Stack.Screen name="settings/hosts/[serverId]/plugin-directory/[owner]/[slug]" />
<Stack.Screen name="settings/hosts/[serverId]/projects/index" />
<Stack.Screen name="settings/hosts/[serverId]/projects/[projectId]" />
<Stack.Screen name="settings/hosts/[serverId]/providers/[providerId]" />
</ThemedStack>
);
}
@@ -0,0 +1,24 @@
import { useLocalSearchParams } from "expo-router";
import { useMemo } from "react";
import { HostRouteBootstrapBoundary } from "@/components/host-route-bootstrap-boundary";
import SettingsScreen from "@/screens/settings-screen";
import { normalizeProjectSettingsRouteId } from "@/utils/host-routes";
export default function SettingsHostProviderDetailRoute() {
const params = useLocalSearchParams<{
serverId?: string | string[];
providerId?: string | string[];
}>();
const serverId = normalizeProjectSettingsRouteId(params.serverId);
const providerId = normalizeProjectSettingsRouteId(params.providerId);
const view = useMemo(
() => ({ kind: "provider" as const, serverId, providerId }),
[providerId, serverId],
);
return (
<HostRouteBootstrapBoundary>
<SettingsScreen view={view} />
</HostRouteBootstrapBoundary>
);
}
+8 -5
View File
@@ -1,6 +1,6 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
import { darkHighlightColors, resolveSyntaxColors } from "@getpaseo/highlight";
import { DEFAULT_UI_FONT_STACK, REGISTERED_THEMES } from "@/styles/theme";
import { DEFAULT_UI_FONT_STACK, REGISTERED_THEMES, type Theme } from "@/styles/theme";
import { applyAppearance, type AppearanceInput } from "./apply";
// Override the global react-native-unistyles mock (vitest.setup.ts) so that
@@ -37,7 +37,7 @@ interface FakeTheme {
"4xl": number;
};
lineHeight: { diff: number };
contentMaxWidth: number;
contentMaxWidth: Theme["contentMaxWidth"];
colors: { foreground: string; syntax: Record<string, string> };
}
@@ -105,10 +105,13 @@ describe("applyAppearance", () => {
]);
});
it("patches the content max width into the theme", () => {
applyAppearance(makeInput({ contentMaxWidth: 1600 }));
it.each([
[1600, "1600px"],
[undefined, "100%"],
])("uses a CSS variable-compatible width on web for %s", (contentMaxWidth, cssWidth) => {
applyAppearance(makeInput({ contentMaxWidth }));
expect(runCapturedUpdater().contentMaxWidth).toBe(1600);
expect(runCapturedUpdater().contentMaxWidth).toBe(cssWidth);
});
it("resolves an empty UI font family to the default stack", () => {
+5 -3
View File
@@ -5,6 +5,7 @@ import {
DEFAULT_MONO_FONT_STACK,
FONT_SIZE,
REGISTERED_THEMES,
themeContentMaxWidth,
type Theme,
} from "@/styles/theme";
import { applyRootUiFont } from "./apply-root-font";
@@ -17,7 +18,7 @@ export interface AppearanceInput {
uiBaseFontSize: number; // already clamped
contentFontSize: number; // already clamped
codeFontSize: number; // already clamped
contentMaxWidth: number; // already clamped, default resolved
contentMaxWidth: number | undefined; // undefined fills the available width
syntaxTheme: SyntaxThemeId;
}
@@ -64,6 +65,7 @@ export function applyAppearance(input: AppearanceInput): void {
const ui = input.uiFontFamily.trim() || DEFAULT_UI_FONT_STACK;
const mono = input.monoFontFamily.trim() || DEFAULT_MONO_FONT_STACK;
const diffLineHeight = Math.round(input.codeFontSize * 1.5); // couple to code size
const contentMaxWidth = themeContentMaxWidth(input.contentMaxWidth);
const activeTheme = UnistylesRuntime.themeName;
// Unistyles web emits after each registry patch. Updating the mounted theme
// first ensures subscribers receive its new numeric tokens in this render;
@@ -87,7 +89,7 @@ export function applyAppearance(input: AppearanceInput): void {
fontFamily,
fontSize,
lineHeight,
contentMaxWidth: input.contentMaxWidth,
contentMaxWidth,
colors: { ...t.colors, syntax: resolveSyntaxColors(input.syntaxTheme, t.colorScheme) },
};
}
@@ -96,7 +98,7 @@ export function applyAppearance(input: AppearanceInput): void {
fontFamily,
fontSize,
lineHeight,
contentMaxWidth: input.contentMaxWidth,
contentMaxWidth,
colors: { ...t.colors, syntax: resolveSyntaxColors(input.syntaxTheme, t.colorScheme) },
};
});
+3 -2
View File
@@ -65,6 +65,7 @@ export function AppearanceProvider({ children }: { children: ReactNode }) {
return options.find((option) => option.id === settings.pluginThemeId) ?? null;
}, [options, settings.pluginThemeId, settings.theme]);
const contentMaxWidth = resolveContentMaxWidth(settings);
useEffect(() => {
if (isLoading) return;
applyTheme({ preference: settings.theme, contributedTheme: selected });
@@ -74,7 +75,7 @@ export function AppearanceProvider({ children }: { children: ReactNode }) {
uiBaseFontSize: settings.uiBaseFontSize,
contentFontSize: settings.contentFontSize,
codeFontSize: settings.codeFontSize,
contentMaxWidth: resolveContentMaxWidth({ contentMaxWidth: settings.contentMaxWidth }),
contentMaxWidth,
syntaxTheme: settings.syntaxTheme,
});
setHasAppliedAppearance(true);
@@ -87,7 +88,7 @@ export function AppearanceProvider({ children }: { children: ReactNode }) {
settings.uiBaseFontSize,
settings.contentFontSize,
settings.codeFontSize,
settings.contentMaxWidth,
contentMaxWidth,
settings.syntaxTheme,
]);
@@ -1,14 +1,20 @@
import type { ReactNode } from "react";
import { View, type StyleProp, type ViewStyle } from "react-native";
import { View, type LayoutChangeEvent, type StyleProp, type ViewStyle } from "react-native";
interface AssistantSelectionCopySurfaceProps {
children: ReactNode;
style?: StyleProp<ViewStyle>;
onLayout?: (event: LayoutChangeEvent) => void;
}
export function AssistantSelectionCopySurface({
children,
style,
onLayout,
}: AssistantSelectionCopySurfaceProps) {
return <View style={style}>{children}</View>;
return (
<View style={style} onLayout={onLayout}>
{children}
</View>
);
}
@@ -1,10 +1,11 @@
import { useCallback, type ClipboardEvent, type CSSProperties, type ReactNode } from "react";
import { View, type StyleProp, type ViewStyle } from "react-native";
import { View, type LayoutChangeEvent, type StyleProp, type ViewStyle } from "react-native";
import { createAssistantSelectionClipboardContent } from "./content.web";
interface AssistantSelectionCopySurfaceProps {
children: ReactNode;
style?: StyleProp<ViewStyle>;
onLayout?: (event: LayoutChangeEvent) => void;
}
const DISPLAY_CONTENTS: CSSProperties = { display: "contents" };
@@ -12,6 +13,7 @@ const DISPLAY_CONTENTS: CSSProperties = { display: "contents" };
export function AssistantSelectionCopySurface({
children,
style,
onLayout,
}: AssistantSelectionCopySurfaceProps) {
const handleCopy = useCallback((event: ClipboardEvent<HTMLDivElement>) => {
const content = createAssistantSelectionClipboardContent(window.getSelection());
@@ -26,7 +28,9 @@ export function AssistantSelectionCopySurface({
return (
<div onCopy={handleCopy} style={DISPLAY_CONTENTS}>
<View style={style}>{children}</View>
<View style={style} onLayout={onLayout}>
{children}
</View>
</div>
);
}
@@ -437,11 +437,13 @@ export function SheetHeaderSubtitle({ text, testID }: { text: string; testID?: s
export function SheetHeaderView({
header,
onClose,
showCloseButton = true,
testID,
closeTestID,
}: {
header: SheetHeader;
onClose: () => void;
showCloseButton?: boolean;
testID?: string;
closeTestID?: string;
}) {
@@ -473,12 +475,14 @@ export function SheetHeaderView({
</View>
<View style={styles.headerTrailing}>
{header.actions}
<SheetHeaderIconButton
icon={X}
label={t("common.actions.close")}
onPress={onClose}
testID={closeTestID}
/>
{showCloseButton ? (
<SheetHeaderIconButton
icon={X}
label={t("common.actions.close")}
onPress={onClose}
testID={closeTestID}
/>
) : null}
</View>
</View>
</IconButtonChromeProvider>
@@ -566,6 +570,11 @@ export interface AdaptiveModalSheetProps {
* corner, and the compact sheet closes from its handle.
*/
header?: SheetHeader;
/**
* Leave out the header's close button when `header.back` is the only way out, as for a sheet
* that stands in for a page of the surface beneath it. Escape still closes the sheet.
*/
showCloseButton?: boolean;
visible: boolean;
onClose: () => void;
onDismiss?: () => void;
@@ -596,6 +605,7 @@ export interface AdaptiveModalSheetProps {
*/
function CompactSheetBody({
header,
showCloseButton,
onClose,
testID,
footer,
@@ -606,6 +616,7 @@ function CompactSheetBody({
children,
}: {
header?: SheetHeader;
showCloseButton: boolean;
onClose: () => void;
testID?: string;
footer: ReactNode;
@@ -635,7 +646,14 @@ function CompactSheetBody({
);
return (
<SheetVisibleFrame footer={footerView}>
{header ? <SheetHeaderView header={header} onClose={onClose} testID={testID} /> : null}
{header ? (
<SheetHeaderView
header={header}
onClose={onClose}
showCloseButton={showCloseButton}
testID={testID}
/>
) : null}
<View style={[styles.compactStaticContent, bodyStyle]}>
{scrollable ? (
<ScrollView
@@ -662,6 +680,7 @@ function CompactSheetBody({
export function AdaptiveModalSheet({
header,
showCloseButton = true,
visible,
onClose,
onDismiss,
@@ -789,6 +808,7 @@ export function AdaptiveModalSheet({
<OverlayLayerProvider layer={modalLayer}>
<CompactSheetBody
header={header}
showCloseButton={showCloseButton}
onClose={onClose}
testID={testID}
footer={footerView}
@@ -808,7 +828,9 @@ export function AdaptiveModalSheet({
desktopHeight == null ? styles.desktopStaticContent : styles.compactStaticContent;
const cardInner = (
<OverlayLayerProvider layer={modalLayer}>
{header ? <SheetHeaderView header={header} onClose={onClose} /> : null}
{header ? (
<SheetHeaderView header={header} onClose={onClose} showCloseButton={showCloseButton} />
) : null}
<View style={[scrollable ? styles.desktopScrollContainer : desktopStaticStyle, bodyStyle]}>
{scrollable ? (
<ScrollView
@@ -1,234 +0,0 @@
import { useCallback, useMemo, useState } from "react";
import { useTranslation } from "react-i18next";
import { Text, View, type LayoutChangeEvent } from "react-native";
import { SvgXml } from "react-native-svg";
import { StyleSheet, withUnistyles } from "react-native-unistyles";
import { PackagePlus } from "lucide-react-native";
import { Button } from "@/components/ui/button";
import { ExternalLink } from "@/components/ui/external-link";
import { SearchField } from "@/components/ui/search-field";
import { StatusBadge } from "@/components/ui/status-badge";
import { rankProviderCatalog } from "@/components/provider-catalog-search";
import {
useAcpProviderCatalog,
type AcpProviderCatalogItem,
} from "@/hooks/use-acp-provider-catalog";
import { useProvidersSnapshot } from "@/hooks/use-providers-snapshot";
import { SPACING, type Theme } from "@/styles/theme";
import { settingsStyles } from "@/styles/settings";
interface ProviderCatalogListProps {
serverId: string;
installingProviderId: string | null;
onInstall: (entry: AcpProviderCatalogItem) => Promise<void> | void;
}
const PROVIDER_FALLBACK_ICON_SIZE = 20;
const PROVIDER_REMOTE_ICON_SIZE = 24;
const TILE_GAP = SPACING[3];
/** Narrowest tile that keeps the icon, type badge, install link, and Add on one row. */
const MIN_TILE_WIDTH = 300;
const MAX_COLUMNS = 4;
const ThemedPackagePlus = withUnistyles(PackagePlus);
const ThemedSvgXml = withUnistyles(SvgXml);
const foregroundColorMapping = (theme: Theme) => ({ color: theme.colors.foreground });
function columnCountForWidth(width: number): number {
const fits = Math.floor((width + TILE_GAP) / (MIN_TILE_WIDTH + TILE_GAP));
return Math.min(MAX_COLUMNS, Math.max(1, fits));
}
interface CatalogTileProps {
entry: AcpProviderCatalogItem;
/** `undefined` until the grid is measured, or in a single column; the tile fills the row. */
width: number | undefined;
installing: boolean;
onInstall: (entry: AcpProviderCatalogItem) => void;
}
function CatalogTile({ entry, width, installing, onInstall }: CatalogTileProps) {
const { t } = useTranslation();
const handleInstall = useCallback(() => {
onInstall(entry);
}, [entry, onInstall]);
const tileStyle = useMemo(
() => [settingsStyles.card, styles.tile, width === undefined ? styles.tileFull : { width }],
[width],
);
return (
<View style={tileStyle} testID={`provider-catalog-tile-${entry.id}`}>
<View style={styles.iconFrame}>
{entry.iconSvg ? (
<ThemedSvgXml
xml={entry.iconSvg}
width={PROVIDER_REMOTE_ICON_SIZE}
height={PROVIDER_REMOTE_ICON_SIZE}
uniProps={foregroundColorMapping}
/>
) : (
<ThemedPackagePlus size={PROVIDER_FALLBACK_ICON_SIZE} uniProps={foregroundColorMapping} />
)}
</View>
<View style={styles.details}>
<Text style={styles.name} numberOfLines={1}>
{entry.title}
</Text>
<View style={styles.metaRow}>
{/* The catalog is the ACP registry, so every entry it offers is an ACP provider. */}
<StatusBadge label={t("providerCatalog.types.acp")} size="xs" />
<ExternalLink
href={entry.installLink}
label={t("providerCatalog.actions.installInstructions")}
accessibilityLabel={t("providerCatalog.actions.installInstructionsFor", {
provider: entry.title,
})}
/>
</View>
</View>
<Button
size="sm"
variant="outline"
disabled={installing}
loading={installing}
onPress={handleInstall}
accessibilityLabel={t("providerCatalog.actions.addProvider", { provider: entry.title })}
style={styles.addButton}
testID={`install-provider-${entry.id}`}
>
{installing ? t("providerCatalog.actions.adding") : t("providerCatalog.actions.add")}
</Button>
</View>
);
}
export function ProviderCatalogList({
serverId,
installingProviderId,
onInstall,
}: ProviderCatalogListProps) {
const { t } = useTranslation();
const { entries: catalogEntries } = useAcpProviderCatalog();
const { entries: providerEntries } = useProvidersSnapshot(serverId);
const [search, setSearch] = useState("");
const [gridWidth, setGridWidth] = useState<number | null>(null);
const installedIds = useMemo(
() => new Set(providerEntries?.map((entry) => entry.provider) ?? []),
[providerEntries],
);
const availableEntries = useMemo(
() =>
rankProviderCatalog(
catalogEntries.filter((entry) => !installedIds.has(entry.id)),
search,
),
[catalogEntries, installedIds, search],
);
const handleGridLayout = useCallback((event: LayoutChangeEvent) => {
setGridWidth(event.nativeEvent.layout.width);
}, []);
const tileWidth = useMemo(() => {
if (gridWidth === null) return undefined;
const columns = columnCountForWidth(gridWidth);
if (columns === 1) return undefined;
return Math.floor((gridWidth - TILE_GAP * (columns - 1)) / columns);
}, [gridWidth]);
return (
<View>
<View style={styles.searchRail}>
<SearchField
value={search}
onChangeText={setSearch}
placeholder={t("providerCatalog.search")}
clearAccessibilityLabel={t("providerCatalog.clearSearch")}
testID="provider-catalog-search"
clearTestID="provider-catalog-search-clear"
/>
</View>
{availableEntries.length === 0 ? (
<View style={[settingsStyles.card, styles.stateBox]}>
<Text style={styles.stateText}>{t("providerCatalog.noProviders")}</Text>
</View>
) : (
<View style={styles.grid} onLayout={handleGridLayout}>
{availableEntries.map((entry) => (
<CatalogTile
key={entry.id}
entry={entry}
width={tileWidth}
installing={installingProviderId === entry.id}
onInstall={onInstall}
/>
))}
</View>
)}
</View>
);
}
const styles = StyleSheet.create((theme) => ({
searchRail: {
flexDirection: "row",
marginBottom: theme.spacing[3],
},
grid: {
flexDirection: "row",
flexWrap: "wrap",
gap: TILE_GAP,
},
tile: {
flexDirection: "row",
alignItems: "center",
gap: theme.spacing[3],
padding: theme.spacing[3],
},
tileFull: {
width: "100%",
},
details: {
flex: 1,
minWidth: 0,
gap: theme.spacing[1],
},
iconFrame: {
flexShrink: 0,
width: 36,
height: 36,
borderRadius: theme.borderRadius.md,
backgroundColor: theme.colors.surface2,
alignItems: "center",
justifyContent: "center",
},
addButton: {
flexShrink: 0,
},
name: {
color: theme.colors.foreground,
fontSize: theme.fontSize.base,
fontWeight: theme.fontWeight.normal,
},
metaRow: {
flexDirection: "row",
flexWrap: "wrap",
alignItems: "center",
gap: theme.spacing[2],
},
stateBox: {
minHeight: 96,
alignItems: "center",
justifyContent: "center",
padding: theme.spacing[4],
},
stateText: {
color: theme.colors.foregroundMuted,
fontSize: theme.fontSize.base,
},
}));
@@ -1,825 +0,0 @@
import * as Clipboard from "expo-clipboard";
import { AlertTriangle, Copy, FileText, Plus, RotateCw, Trash2 } from "lucide-react-native";
import type { TFunction } from "i18next";
import { useCallback, useEffect, useMemo, useRef, useState } from "react";
import { useTranslation } from "react-i18next";
import { Pressable, type PressableStateCallbackType, Text, View } from "react-native";
import { StyleSheet, useUnistyles } from "react-native-unistyles";
import {
AdaptiveModalSheet,
AdaptiveTextInput,
SheetHeaderIconButton,
type SheetHeader,
} from "@/components/adaptive-modal-sheet";
import { Button } from "@/components/ui/button";
import { LoadingSpinner } from "@/components/ui/loading-spinner";
import { ScrollableCodeSurface, SurfaceCard } from "@/components/ui/scrollable-code-surface";
import { useIsCompactFormFactor } from "@/constants/layout";
import { isWeb } from "@/constants/platform";
import { useToast } from "@/contexts/toast-context";
import { CODE_SURFACE_DATASET } from "@/styles/code-surface";
import { useDaemonConfig } from "@/hooks/use-daemon-config";
import { useProvidersSnapshot } from "@/hooks/use-providers-snapshot";
import { useTimeAgo } from "@/hooks/use-time-ago";
import { useHostRuntimeClient } from "@/runtime/host-runtime";
import { settingsStyles } from "@/styles/settings";
import { resolveProviderLabel } from "@/utils/provider-definitions";
import { compareMatchScores, scoreTextFields } from "@getpaseo/protocol/search/text-match";
import type { AgentModelDefinition, AgentProvider } from "@getpaseo/protocol/agent-types";
import type { ProviderProfileModel } from "@getpaseo/protocol/provider-config";
import {
resolveProviderDiscoveredModels,
type ProviderDiscoveredModelsCache,
} from "./provider-diagnostic-models";
interface ProviderDiagnosticSheetProps {
provider: string;
visible: boolean;
onClose: () => void;
serverId: string;
}
function rankModels<T>(items: T[], query: string, fields: (item: T) => string[]): T[] {
if (!query.trim()) return items;
const scored = items
.map((item) => ({ item, score: scoreTextFields(query, fields(item)) }))
.filter(
(entry): entry is { item: T; score: NonNullable<typeof entry.score> } => entry.score !== null,
);
scored.sort((a, b) => compareMatchScores(a.score, b.score));
return scored.map((entry) => entry.item);
}
function DiscoveredModelRow({ model }: { model: AgentModelDefinition }) {
return (
<View style={sheetStyles.modelRow}>
<Text style={sheetStyles.modelTitle} numberOfLines={1}>
{model.label}
</Text>
<Text
style={sheetStyles.monoHint}
numberOfLines={1}
selectable
dataSet={CODE_SURFACE_DATASET}
>
{model.id}
</Text>
{model.description ? (
<Text style={sheetStyles.descriptionInline} numberOfLines={1}>
{model.description}
</Text>
) : null}
</View>
);
}
function CustomModelRow({
model,
deleting,
onDelete,
}: {
model: ProviderProfileModel;
deleting: boolean;
onDelete: (modelId: string) => void;
}) {
const { t } = useTranslation();
const { theme } = useUnistyles();
const handleDelete = useCallback(() => onDelete(model.id), [model.id, onDelete]);
const deleteButtonStyle = useCallback(
({ hovered, pressed }: PressableStateCallbackType & { hovered?: boolean }) => [
sheetStyles.iconButton,
(Boolean(hovered) || pressed) && sheetStyles.iconButtonHovered,
deleting ? sheetStyles.disabled : null,
],
[deleting],
);
return (
<View style={sheetStyles.modelRow}>
<Text style={[sheetStyles.modelTitle, sheetStyles.customModelText]} numberOfLines={1}>
{model.label}
</Text>
<Text
style={[sheetStyles.monoHint, sheetStyles.customModelText]}
numberOfLines={1}
selectable
dataSet={CODE_SURFACE_DATASET}
>
{model.id}
</Text>
<View style={sheetStyles.modelRowFiller} />
<Pressable
onPress={handleDelete}
disabled={deleting}
hitSlop={8}
style={deleteButtonStyle}
accessibilityRole="button"
accessibilityLabel={t("settings.providers.models.removeModel", { id: model.id })}
>
<Trash2 size={theme.iconSize.sm} color={theme.colors.destructive} />
</Pressable>
</View>
);
}
function SectionHeader({ title, count, hint }: { title: string; count?: number; hint?: string }) {
return (
<View style={sheetStyles.sectionHeader}>
<Text style={settingsStyles.sectionHeaderTitle}>{title}</Text>
<View style={sheetStyles.sectionHeaderMeta}>
{count !== undefined ? (
<Text style={settingsStyles.sectionHeaderTitle}>{count}</Text>
) : null}
{count !== undefined && hint ? (
<Text style={settingsStyles.sectionHeaderTitle}>·</Text>
) : null}
{hint ? <Text style={settingsStyles.sectionHeaderTitle}>{hint}</Text> : null}
</View>
</View>
);
}
function AddCustomModelSubSheet({
provider,
serverId,
visible,
onClose,
refresh,
}: {
provider: string;
serverId: string;
visible: boolean;
onClose: () => void;
refresh: (providers?: AgentProvider[]) => Promise<void>;
}) {
const { t } = useTranslation();
const { theme } = useUnistyles();
const { config, patchConfig } = useDaemonConfig(serverId);
const [input, setInput] = useState("");
const [error, setError] = useState<string | null>(null);
const [saving, setSaving] = useState(false);
const additionalModels = useMemo(
() => config?.providers?.[provider]?.additionalModels ?? [],
[config?.providers, provider],
);
const trimmed = input.trim();
const canAdd = trimmed.length > 0 && !additionalModels.some((model) => model.id === trimmed);
useEffect(() => {
if (!visible) {
setInput("");
setError(null);
}
}, [visible]);
const handleAdd = useCallback(() => {
if (!canAdd) return;
setError(null);
setSaving(true);
void patchConfig({
providers: {
[provider]: {
additionalModels: [...additionalModels, { id: trimmed, label: trimmed }],
},
},
})
.then(() => refresh([provider]))
.then(() => onClose())
.catch((err) => {
setError(err instanceof Error ? err.message : t("settings.providers.models.failedToSave"));
})
.finally(() => setSaving(false));
}, [additionalModels, canAdd, onClose, patchConfig, provider, refresh, t, trimmed]);
const header = useMemo<SheetHeader>(
() => ({ title: t("settings.providers.models.addCustomTitle") }),
[t],
);
return (
<AdaptiveModalSheet
header={header}
visible={visible}
onClose={onClose}
desktopMaxWidth={420}
snapPoints={ADD_SNAP_POINTS}
testID="add-custom-model-sheet"
>
<View style={sheetStyles.formGroup}>
<Text style={sheetStyles.formLabel}>{t("settings.providers.models.modelId")}</Text>
<AdaptiveTextInput
initialValue={input}
resetKey={`add-custom-${visible}`}
onChangeText={setInput}
onSubmitEditing={handleAdd}
placeholder={t("settings.providers.models.modelIdPlaceholder")}
placeholderTextColor={theme.colors.foregroundMuted}
autoCapitalize="none"
autoCorrect={false}
returnKeyType="done"
// @ts-expect-error - outlineStyle is web-only
style={[sheetStyles.formInput, isWeb && { outlineStyle: "none" }]}
/>
{error ? <Text style={sheetStyles.errorText}>{error}</Text> : null}
<View style={sheetStyles.formActions}>
<Button variant="secondary" onPress={onClose} disabled={saving}>
{t("common.actions.cancel")}
</Button>
<Button variant="default" onPress={handleAdd} disabled={!canAdd || saving}>
{saving ? t("settings.providers.models.adding") : t("settings.providers.models.add")}
</Button>
</View>
</View>
</AdaptiveModalSheet>
);
}
function DiagnosticSubSheet({
provider,
serverId,
visible,
onClose,
}: {
provider: string;
serverId: string;
visible: boolean;
onClose: () => void;
}) {
const { t } = useTranslation();
const { theme } = useUnistyles();
const toast = useToast();
const client = useHostRuntimeClient(serverId);
const [diagnostic, setDiagnostic] = useState<string | null>(null);
const [loading, setLoading] = useState(false);
const fetchDiagnostic = useCallback(async () => {
if (!client) return;
setLoading(true);
try {
const result = await client.getProviderDiagnostic(provider);
setDiagnostic(result.diagnostic);
} catch (err) {
setDiagnostic(
err instanceof Error ? err.message : t("settings.providers.diagnostic.failedToFetch"),
);
} finally {
setLoading(false);
}
}, [client, provider, t]);
useEffect(() => {
if (visible) {
void fetchDiagnostic();
} else {
setDiagnostic(null);
}
}, [visible, fetchDiagnostic]);
const handleRefreshPress = useCallback(() => {
void fetchDiagnostic();
}, [fetchDiagnostic]);
const handleCopyPress = useCallback(() => {
if (!diagnostic) return;
void Clipboard.setStringAsync(diagnostic)
.then(() => toast.copied(t("settings.providers.diagnostic.copyLabel")))
.catch(() => toast.error(t("settings.providers.diagnostic.copyFailed")));
}, [diagnostic, t, toast]);
const header = useMemo<SheetHeader>(
() => ({
title: t("settings.providers.diagnostic.title"),
actions: (
<>
<SheetHeaderIconButton
icon={Copy}
label={t("settings.providers.diagnostic.copyAccessibility")}
onPress={handleCopyPress}
disabled={!diagnostic}
/>
<SheetHeaderIconButton
icon={RotateCw}
label={
loading
? t("settings.providers.diagnostic.refreshingAccessibility")
: t("settings.providers.diagnostic.refreshAccessibility")
}
onPress={handleRefreshPress}
busy={loading}
/>
</>
),
}),
[diagnostic, handleCopyPress, handleRefreshPress, loading, t],
);
let body: React.ReactNode;
if (loading && !diagnostic) {
body = (
<SurfaceCard key={visible ? "visible" : "hidden"}>
<View style={sheetStyles.codeBlockLoading}>
<LoadingSpinner size="small" color={theme.colors.foregroundMuted} />
<Text style={sheetStyles.mutedText}>{t("settings.providers.diagnostic.running")}</Text>
</View>
</SurfaceCard>
);
} else if (diagnostic) {
body = (
<ScrollableCodeSurface key={visible ? "visible" : "hidden"} maxHeight={480}>
{diagnostic}
</ScrollableCodeSurface>
);
} else {
body = (
<SurfaceCard key={visible ? "visible" : "hidden"}>
<View style={sheetStyles.codeBlockLoading}>
<Text style={sheetStyles.mutedText}>{t("settings.providers.diagnostic.none")}</Text>
</View>
</SurfaceCard>
);
}
return (
<AdaptiveModalSheet
header={header}
visible={visible}
onClose={onClose}
snapPoints={DIAGNOSTIC_SNAP_POINTS}
scrollable={false}
testID="provider-diagnostic-sheet"
>
{body}
</AdaptiveModalSheet>
);
}
interface ProviderModalBodyProps {
discoveredCount: number;
additionalCount: number;
providerSnapshotRefreshing: boolean;
providerErrorMessage: string | null;
modelsRefreshing: boolean;
searchActive: boolean;
filteredDiscovered: AgentModelDefinition[];
filteredCustom: ProviderProfileModel[];
deletingModelId: string | null;
onRefresh: () => void;
onDeleteCustom: (modelId: string) => void;
theme: { iconSize: { md: number }; colors: { foregroundMuted: string } };
}
interface ProviderSheetFooterInput {
fetchedAt: string | null;
isCompact: boolean;
modelsRefreshing: boolean;
t: TFunction;
onOpenAddSheet: () => void;
onOpenDiagSheet: () => void;
onRefreshModels: () => void;
}
function renderProviderSheetFooter({
fetchedAt,
isCompact,
modelsRefreshing,
t,
onOpenAddSheet,
onOpenDiagSheet,
onRefreshModels,
}: ProviderSheetFooterInput) {
const contentStyle = isCompact ? sheetStyles.compactFooterContent : sheetStyles.footerContent;
const actionsStyle = isCompact ? sheetStyles.compactFooterActions : sheetStyles.footerActions;
const buttonStyle = isCompact ? sheetStyles.compactFooterButton : null;
return (
<View style={contentStyle}>
{fetchedAt || !isCompact ? (
<ProviderUpdatedLabel fetchedAt={fetchedAt} isCompact={isCompact} />
) : null}
<View style={actionsStyle}>
<Button variant="secondary" leftIcon={Plus} onPress={onOpenAddSheet} style={buttonStyle}>
{t("settings.providers.models.addModel")}
</Button>
<Button
variant="secondary"
leftIcon={FileText}
onPress={onOpenDiagSheet}
style={buttonStyle}
>
{t("settings.providers.diagnostic.button")}
</Button>
<Button
variant="default"
leftIcon={modelsRefreshing ? undefined : RotateCw}
onPress={onRefreshModels}
disabled={modelsRefreshing}
style={buttonStyle}
>
{modelsRefreshing
? t("settings.providers.diagnostic.refreshing")
: t("settings.providers.diagnostic.refresh")}
</Button>
</View>
</View>
);
}
function ProviderUpdatedLabel({
fetchedAt,
isCompact,
}: {
fetchedAt: string | null;
isCompact: boolean;
}) {
const { t } = useTranslation();
const label = useTimeAgo(fetchedAt ? new Date(fetchedAt) : null);
const style = isCompact
? [sheetStyles.footerMeta, sheetStyles.compactFooterMeta]
: sheetStyles.footerMeta;
return (
<Text style={style} numberOfLines={1}>
{fetchedAt ? t("settings.providers.models.updated", { time: label }) : ""}
</Text>
);
}
function ProviderModalBody(props: ProviderModalBodyProps) {
const { t } = useTranslation();
const {
discoveredCount,
additionalCount,
providerSnapshotRefreshing,
providerErrorMessage,
modelsRefreshing,
searchActive,
filteredDiscovered,
filteredCustom,
deletingModelId,
onRefresh,
onDeleteCustom,
theme,
} = props;
if (discoveredCount === 0 && additionalCount === 0 && providerSnapshotRefreshing) {
return (
<View style={sheetStyles.emptyState}>
<LoadingSpinner size="small" color={theme.colors.foregroundMuted} />
<Text style={sheetStyles.mutedText}>{t("settings.providers.models.loading")}</Text>
</View>
);
}
if (discoveredCount === 0 && additionalCount === 0 && providerErrorMessage) {
return (
<View style={sheetStyles.emptyState}>
<AlertTriangle size={theme.iconSize.md} color={theme.colors.foregroundMuted} />
<Text style={sheetStyles.mutedText}>{providerErrorMessage}</Text>
<Button variant="default" onPress={onRefresh} disabled={modelsRefreshing}>
{modelsRefreshing
? t("settings.providers.models.retrying")
: t("settings.providers.models.retry")}
</Button>
</View>
);
}
if (filteredDiscovered.length === 0 && filteredCustom.length === 0 && searchActive) {
return (
<View style={sheetStyles.emptyState}>
<Text style={sheetStyles.mutedText}>{t("settings.providers.models.noSearchMatches")}</Text>
</View>
);
}
if (discoveredCount === 0 && additionalCount === 0) {
return (
<View style={sheetStyles.emptyState}>
<Text style={sheetStyles.mutedText}>{t("settings.providers.models.noneDetected")}</Text>
</View>
);
}
return (
<>
{filteredDiscovered.length > 0 ? (
<View style={sheetStyles.section}>
<SectionHeader
title={t("settings.providers.models.discovered")}
count={filteredDiscovered.length}
/>
<View style={settingsStyles.card}>
{filteredDiscovered.map((model) => (
<DiscoveredModelRow key={model.id} model={model} />
))}
</View>
</View>
) : null}
{filteredCustom.length > 0 ? (
<View style={sheetStyles.section}>
<SectionHeader
title={t("settings.providers.models.custom")}
count={filteredCustom.length}
/>
<View style={settingsStyles.card}>
{filteredCustom.map((model) => (
<CustomModelRow
key={model.id}
model={model}
deleting={deletingModelId === model.id}
onDelete={onDeleteCustom}
/>
))}
</View>
</View>
) : null}
</>
);
}
export function ProviderDiagnosticSheet({
provider,
visible,
onClose,
serverId,
}: ProviderDiagnosticSheetProps) {
const { t } = useTranslation();
const { theme } = useUnistyles();
const isCompact = useIsCompactFormFactor();
const { entries: snapshotEntries, refresh, isRefreshing } = useProvidersSnapshot(serverId);
const { config, patchConfig } = useDaemonConfig(serverId);
const [query, setQuery] = useState("");
const [addSheetOpen, setAddSheetOpen] = useState(false);
const [diagSheetOpen, setDiagSheetOpen] = useState(false);
const [deletingModelId, setDeletingModelId] = useState<string | null>(null);
const providerLabel = resolveProviderLabel(provider, snapshotEntries);
const providerEntry = useMemo(
() => snapshotEntries?.find((entry) => entry.provider === provider),
[snapshotEntries, provider],
);
const additionalModels = useMemo(
() => config?.providers?.[provider]?.additionalModels ?? [],
[config?.providers, provider],
);
const providerSnapshotRefreshing = providerEntry?.status === "loading";
const providerErrorMessage =
providerEntry?.status === "error"
? (providerEntry.error ?? t("settings.providers.diagnostic.unknownError"))
: null;
const modelsRefreshing = isRefreshing || providerSnapshotRefreshing;
const stableDiscoveredRef = useRef<ProviderDiscoveredModelsCache | null>(null);
const currentModels = providerEntry?.models;
const { models: discoveredModels, cache: nextDiscoveredCache } = resolveProviderDiscoveredModels({
serverId,
provider,
currentModels,
providerSnapshotRefreshing,
previousCache: stableDiscoveredRef.current,
});
stableDiscoveredRef.current = nextDiscoveredCache;
useEffect(() => {
if (!visible) {
setQuery("");
setAddSheetOpen(false);
setDiagSheetOpen(false);
}
}, [visible]);
const q = query.trim();
const filteredDiscovered = useMemo(
() => rankModels(discoveredModels, q, (m) => [m.label, m.id, m.description ?? ""]),
[discoveredModels, q],
);
const filteredCustom = useMemo(
() => rankModels(additionalModels, q, (m) => [m.label, m.id]),
[additionalModels, q],
);
const handleRefreshModels = useCallback(() => {
void refresh([provider]);
}, [provider, refresh]);
const handleOpenAddSheet = useCallback(() => setAddSheetOpen(true), []);
const handleCloseAddSheet = useCallback(() => setAddSheetOpen(false), []);
const handleOpenDiagSheet = useCallback(() => setDiagSheetOpen(true), []);
const handleCloseDiagSheet = useCallback(() => setDiagSheetOpen(false), []);
const handleDeleteCustom = useCallback(
(modelId: string) => {
setDeletingModelId(modelId);
void patchConfig({
providers: {
[provider]: {
additionalModels: additionalModels.filter((model) => model.id !== modelId),
},
},
})
.then(() => refresh([provider]))
.finally(() => {
setDeletingModelId((current) => (current === modelId ? null : current));
});
},
[additionalModels, patchConfig, provider, refresh],
);
const sheetHeader = useMemo<SheetHeader>(
() => ({
title: providerLabel,
search: {
onChange: setQuery,
placeholder: t("settings.providers.models.searchPlaceholder"),
testID: "provider-settings-search",
},
}),
[providerLabel, t],
);
return (
<>
<AdaptiveModalSheet
header={sheetHeader}
visible={visible}
onClose={onClose}
testID="provider-settings-sheet"
footer={renderProviderSheetFooter({
fetchedAt: providerEntry?.fetchedAt ?? null,
isCompact,
modelsRefreshing,
t,
onOpenAddSheet: handleOpenAddSheet,
onOpenDiagSheet: handleOpenDiagSheet,
onRefreshModels: handleRefreshModels,
})}
snapPoints={MAIN_SNAP_POINTS}
>
<ProviderModalBody
discoveredCount={discoveredModels.length}
additionalCount={additionalModels.length}
providerSnapshotRefreshing={providerSnapshotRefreshing}
providerErrorMessage={providerErrorMessage}
modelsRefreshing={modelsRefreshing}
searchActive={Boolean(q)}
filteredDiscovered={filteredDiscovered}
filteredCustom={filteredCustom}
deletingModelId={deletingModelId}
onRefresh={handleRefreshModels}
onDeleteCustom={handleDeleteCustom}
theme={theme}
/>
</AdaptiveModalSheet>
<AddCustomModelSubSheet
provider={provider}
serverId={serverId}
visible={addSheetOpen}
onClose={handleCloseAddSheet}
refresh={refresh}
/>
<DiagnosticSubSheet
provider={provider}
serverId={serverId}
visible={diagSheetOpen}
onClose={handleCloseDiagSheet}
/>
</>
);
}
const sheetStyles = StyleSheet.create((theme) => ({
mutedText: {
fontSize: theme.fontSize.base,
color: theme.colors.foregroundMuted,
},
monoHint: {
fontFamily: theme.fontFamily.mono,
fontSize: theme.fontSize.code,
color: theme.colors.foregroundMuted,
flexShrink: 0,
},
descriptionInline: {
flex: 1,
fontSize: theme.fontSize.sm,
color: theme.colors.foregroundMuted,
},
errorText: {
fontSize: theme.fontSize.sm,
color: theme.colors.destructive,
},
formInput: {
backgroundColor: theme.colors.surface2,
borderRadius: theme.borderRadius.lg,
paddingHorizontal: theme.spacing[4],
paddingVertical: theme.spacing[3],
color: theme.colors.foreground,
borderWidth: 1,
borderColor: theme.colors.border,
fontSize: theme.fontSize.base,
},
iconButton: {
width: 28,
height: 28,
flexShrink: 0,
borderRadius: theme.borderRadius.full,
alignItems: "center",
justifyContent: "center",
},
iconButtonHovered: {
backgroundColor: theme.colors.surface2,
},
disabled: {
opacity: 0.5,
},
section: {
marginBottom: theme.spacing[4],
},
sectionHeader: {
flexDirection: "row",
alignItems: "center",
justifyContent: "space-between",
gap: theme.spacing[2],
marginBottom: theme.spacing[2],
marginLeft: theme.spacing[1],
},
sectionHeaderMeta: {
flexDirection: "row",
alignItems: "center",
gap: theme.spacing[1],
},
modelRow: {
flexDirection: "row",
alignItems: "center",
paddingVertical: theme.spacing[2],
paddingHorizontal: theme.spacing[4],
gap: theme.spacing[3],
borderTopWidth: 1,
borderTopColor: theme.colors.border,
},
modelTitle: {
color: theme.colors.foreground,
fontSize: theme.fontSize.base,
flexShrink: 0,
},
customModelText: {
flexShrink: 1,
minWidth: 0,
},
modelRowFiller: {
flex: 1,
},
emptyState: {
paddingVertical: theme.spacing[8],
alignItems: "center",
gap: theme.spacing[3],
},
footerContent: {
flex: 1,
flexDirection: "row",
alignItems: "center",
justifyContent: "space-between",
gap: theme.spacing[2],
},
compactFooterContent: {
flex: 1,
gap: theme.spacing[2],
},
footerMeta: {
flex: 1,
fontSize: theme.fontSize.sm,
color: theme.colors.foregroundMuted,
},
compactFooterMeta: {
flex: 0,
},
footerActions: {
flexDirection: "row",
alignItems: "center",
gap: theme.spacing[2],
},
compactFooterActions: {
gap: theme.spacing[2],
},
compactFooterButton: {
alignSelf: "stretch",
},
formGroup: {
gap: theme.spacing[3],
},
formLabel: {
fontSize: theme.fontSize.base,
fontWeight: theme.fontWeight.medium,
color: theme.colors.foreground,
},
formActions: {
flexDirection: "row",
justifyContent: "flex-end",
gap: theme.spacing[2],
},
codeBlockLoading: {
paddingVertical: theme.spacing[4],
paddingHorizontal: theme.spacing[4],
flexDirection: "row",
alignItems: "center",
gap: theme.spacing[2],
},
}));
const MAIN_SNAP_POINTS = ["65%", "92%"];
const ADD_SNAP_POINTS = ["40%"];
const DIAGNOSTIC_SNAP_POINTS = ["50%", "85%"];
@@ -0,0 +1,480 @@
import React, { act } from "react";
import { createRoot, type Root } from "react-dom/client";
import { within } from "@testing-library/dom";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { i18n as testI18n } from "@/i18n/i18next";
import {
ProviderInstallationSection,
type ProviderInstallationState,
type ProviderUpdateAction,
type ProviderUpdatesState,
} from "./provider-installation-section";
// Load translations so controls expose their real accessible names.
void testI18n;
// App sources compile against the classic JSX runtime, which expects React on the global.
beforeEach(() => vi.stubGlobal("React", React));
const mounted: { root: Root; container: HTMLDivElement }[] = [];
afterEach(() => {
for (const entry of mounted.splice(0)) {
act(() => entry.root.unmount());
entry.container.remove();
}
});
const INSTALL_URL = "https://example.com/install";
const UPDATE_URL = "https://example.com/update";
function mount(
state: ProviderInstallationState,
updates: ProviderUpdatesState = { status: "hidden" },
action?: ProviderUpdateAction,
) {
const container = document.createElement("div");
document.body.appendChild(container);
const root = createRoot(container);
act(() =>
root.render(<ProviderInstallationSection state={state} updates={updates} action={action} />),
);
mounted.push({ root, container });
const view = within(container);
return {
view,
rerender: (nextUpdates: ProviderUpdatesState, nextAction?: ProviderUpdateAction) =>
act(() =>
root.render(
<ProviderInstallationSection state={state} updates={nextUpdates} action={nextAction} />,
),
),
installButton: () => view.queryByRole("button", { name: "Install" }),
installLink: () => view.queryByRole("link", { name: "Install instructions" }),
};
}
function ready(installation: ProviderInstallationState & { status: "ready" }) {
return installation;
}
describe("install link visibility", () => {
it("offers the Install button when the provider reports it is not installed", () => {
const section = mount(
ready({
status: "ready",
installation: { installUrl: INSTALL_URL, inspection: { status: "not_installed" } },
}),
);
expect(section.installButton()).not.toBeNull();
expect(section.installLink()).toBeNull();
});
it("offers a quiet install link when the installation check failed", async () => {
const section = mount(
ready({
status: "ready",
installation: {
installUrl: INSTALL_URL,
inspection: { status: "error", message: "version probe exploded" },
},
}),
);
await expect.element(section.view.getByText("version probe exploded")).toBeVisible();
expect(section.installLink()).not.toBeNull();
expect(section.installButton()).toBeNull();
});
it("offers a quiet install link for a provider that only declares where to install it", () => {
const section = mount(ready({ status: "ready", installation: { installUrl: INSTALL_URL } }));
expect(section.installLink()).not.toBeNull();
expect(section.installButton()).toBeNull();
});
it("offers no install link once the provider reports it is installed", () => {
const section = mount(
ready({
status: "ready",
installation: {
installUrl: INSTALL_URL,
inspection: { status: "installed", version: "1" },
},
}),
);
expect(section.installLink()).toBeNull();
expect(section.installButton()).toBeNull();
});
});
describe("update check", () => {
const installed = ready({
status: "ready",
installation: {
installUrl: INSTALL_URL,
updateUrl: UPDATE_URL,
inspection: { status: "installed", version: "0.165.0" },
},
});
it("shows the reported versions and message as written, with Update instructions", async () => {
const section = mount(installed, {
status: "ready",
updateCheck: {
status: "available",
versions: ["0.168.0", "nightly (unstable)"],
message: "Restart to finish",
},
});
await expect.element(section.view.getByText("Update available")).toBeVisible();
expect(
section.view.getAllByTestId("provider-updates-version").map((node) => node.textContent),
).toEqual(["0.168.0", "nightly (unstable)"]);
await expect.element(section.view.getByText("Restart to finish")).toBeVisible();
await expect
.element(section.view.getByRole("button", { name: "Update instructions" }))
.toBeVisible();
});
const inconclusive = [
{
name: "unknown",
updates: { status: "ready", updateCheck: { status: "unknown", message: "Offline" } },
},
{
name: "a thrown or timed-out check",
updates: { status: "ready", updateCheck: { status: "error", message: "Offline" } },
},
{ name: "a failed request", updates: { status: "error", message: "Offline" } },
] as const;
it.each(inconclusive)("shows $name as inconclusive, never up to date", async ({ updates }) => {
const section = mount(installed, updates);
await expect.element(section.view.getByText("Couldn't check for updates")).toBeVisible();
await expect.element(section.view.getByText("Offline")).toBeVisible();
expect(section.view.queryByText("Up to date")).toBeNull();
await expect
.element(section.view.getByRole("button", { name: "Update instructions" }))
.toBeVisible();
});
it.each(inconclusive)(
"still says $name when the provider offers no update",
async ({ updates }) => {
const section = mount(
ready({
status: "ready",
installation: { inspection: { status: "installed", version: "0.165.0" } },
}),
updates,
);
await expect.element(section.view.getByText("Couldn't check for updates")).toBeVisible();
expect(section.view.queryByRole("button")).toBeNull();
},
);
it("shows up to date only when the provider says so", async () => {
const section = mount(installed, { status: "ready", updateCheck: { status: "current" } });
await expect.element(section.view.getByText("Up to date")).toBeVisible();
});
it("shows the check's answer for a provider that offers no update", async () => {
const section = mount(
ready({
status: "ready",
installation: { inspection: { status: "installed", version: "1.4.18" } },
}),
{ status: "ready", updateCheck: { status: "current" } },
);
await expect.element(section.view.getByText("Up to date")).toBeVisible();
expect(section.view.queryByRole("button")).toBeNull();
});
it.each([
{ name: "cannot check", updates: { status: "ready", updateCheck: null } },
{ name: "is still checking", updates: { status: "loading" } },
] as const)(
"shows no Updates row while a provider that offers no update $name",
({ updates }) => {
const section = mount(
ready({
status: "ready",
installation: {
installUrl: INSTALL_URL,
inspection: { status: "installed", version: "1.0.0" },
},
}),
updates,
);
expect(section.view.queryByTestId("provider-updates")).toBeNull();
expect(section.view.getByTestId("provider-installation-version").textContent).toBe("1.0.0");
},
);
});
describe("update action", () => {
const installed = (canUpdate: boolean) =>
ready({
status: "ready",
installation: {
updateUrl: UPDATE_URL,
inspection: { status: "installed", version: "1.0.0" },
...(canUpdate ? { canUpdate: true } : {}),
},
});
const available: ProviderUpdatesState = {
status: "ready",
updateCheck: { status: "available", versions: ["2.0.0"] },
};
function action(overrides: Partial<ProviderUpdateAction> = {}) {
let starts = 0;
const value: ProviderUpdateAction = {
current: null,
starting: false,
startError: null,
start: () => {
starts += 1;
},
...overrides,
};
return { value, starts: () => starts };
}
const operation = { id: "op", startedAt: "2026-11-13T00:00:00.000Z" };
const finishedAt = "2026-11-13T00:01:00.000Z";
// The check only informs: Update and the update instructions never wait on it.
const checkStates = [
{ name: "an update is available", updates: available, says: "Update available" },
// No check answer: the row shows only its title (asserted whole below).
{
name: "the provider cannot check",
updates: { status: "ready", updateCheck: null },
says: "Updates",
},
{ name: "the check is running", updates: { status: "loading" }, says: "Checking..." },
{
name: "the check could not tell",
updates: { status: "ready", updateCheck: { status: "unknown" } },
says: "Couldn't check for updates",
},
{
name: "the check failed",
updates: { status: "error", message: "Offline" },
says: "Couldn't check for updates",
},
{
name: "the provider is up to date",
updates: { status: "ready", updateCheck: { status: "current" } },
says: "Up to date",
},
] satisfies { name: string; updates: ProviderUpdatesState; says: string }[];
it.each(checkStates)(
"offers Update when $name and the provider runs its own",
async ({ updates, says }) => {
const control = action();
const section = mount(installed(true), updates, control.value);
const button = section.view.getByRole("button", { name: "Update" });
act(() => button.click());
expect(control.starts()).toBe(1);
expect(section.view.queryByRole("button", { name: "Update instructions" })).toBeNull();
await expect.element(section.view.getByText(says, { exact: true })).toBeVisible();
},
);
it.each(checkStates)(
"offers Update instructions when $name and the provider only links its guide",
async ({ updates }) => {
const section = mount(installed(false), updates, action().value);
expect(section.view.queryByRole("button", { name: "Update" })).toBeNull();
await expect
.element(section.view.getByRole("button", { name: "Update instructions" }))
.toBeVisible();
},
);
it("shows no update status beside Update when the provider cannot check", () => {
const section = mount(installed(true), { status: "ready", updateCheck: null }, action().value);
expect(section.view.getByTestId("provider-updates").textContent).toBe("UpdatesUpdate");
});
it("shows a running update with its output so far", () => {
const section = mount(
installed(true),
available,
action({
current: {
operation: { ...operation, status: "running" },
output: [
{ type: "message", text: "Running codex update\n" },
{ type: "stdout", text: "added 1 package\n" },
],
},
}).value,
);
expect(section.view.queryByTestId("provider-update-status")).toBeNull();
expect(section.view.getByTestId("provider-update-output").textContent).toBe(
"Running codex update\nadded 1 package\n",
);
});
it("shows the provider's success message as written", () => {
const section = mount(
installed(true),
{ status: "ready", updateCheck: { status: "current" } },
action({
current: {
operation: {
...operation,
status: "succeeded",
finishedAt,
message: " Restart agents \n",
},
output: [],
},
}).value,
);
expect(section.view.getByTestId("provider-update-status").textContent).toBe("Updated");
expect(section.view.getByTestId("provider-update-message").textContent).toBe(
" Restart agents \n",
);
expect(section.view.queryByTestId("provider-update-output")).toBeNull();
});
it("shows a failure with its message, its output and the update instructions", async () => {
const section = mount(
installed(true),
available,
action({
current: {
operation: { ...operation, status: "failed", finishedAt, message: "exited with code 1" },
output: [{ type: "stderr", text: "npm error EACCES\n" }],
truncated: true,
},
}).value,
);
expect(section.view.getByTestId("provider-update-status").textContent).toBe("Update failed");
await expect.element(section.view.getByText("exited with code 1")).toBeVisible();
expect(section.view.getByTestId("provider-update-output").textContent).toBe(
"npm error EACCES\n",
);
await expect.element(section.view.getByText("Earlier output was dropped.")).toBeVisible();
await expect
.element(section.view.getByRole("link", { name: "Update instructions" }))
.toBeVisible();
await expect.element(section.view.getByRole("button", { name: "Update" })).toBeVisible();
});
// Update carries the update's progress from the tap until it settles, like every in-flight
// button in Settings. The update's row shows only its output meanwhile.
describe("progress", () => {
const runningUpdate = (output: string[] = []) => ({
operation: { ...operation, status: "running" as const },
output: output.map((text) => ({ type: "stdout" as const, text })),
});
function progress(section: ReturnType<typeof mount>) {
const indicators = section.view.queryAllByRole("progressbar");
const button = section.view.queryByTestId("provider-update-start");
return {
count: indicators.length,
inButton: indicators.every((indicator) => button?.contains(indicator) ?? false),
label: button?.textContent,
pressable: button?.getAttribute("aria-disabled") !== "true",
};
}
const updating = { count: 1, inButton: true, label: "Updating...", pressable: false };
const idle = { count: 0, inButton: true, label: "Update", pressable: true };
it("shows progress on Update alone from tap to settle", () => {
const previous = {
operation: { ...operation, status: "failed" as const, finishedAt, message: "exit 1" },
output: [{ type: "stderr" as const, text: "old failure\n" }],
};
const section = mount(installed(true), available, action({ current: previous }).value);
expect(progress(section)).toEqual(idle);
// Tapped, the host has not answered yet: the previous result gives way to the new update.
section.rerender(available, action({ current: previous, starting: true }).value);
expect(progress(section)).toEqual(updating);
expect(section.view.queryByTestId("provider-update-run")).toBeNull();
// Running before any output arrives.
section.rerender(available, action({ current: runningUpdate() }).value);
expect(progress(section)).toEqual(updating);
expect(section.view.queryByTestId("provider-update-run")).toBeNull();
section.rerender(available, action({ current: runningUpdate(["downloading\n"]) }).value);
expect(progress(section)).toEqual(updating);
expect(section.view.getByTestId("provider-update-run").textContent).toBe("downloading\n");
section.rerender(
{ status: "ready", updateCheck: { status: "current" } },
action({
current: {
...runningUpdate(["downloading\n"]),
operation: { ...operation, status: "succeeded", finishedAt },
},
}).value,
);
expect(progress(section)).toEqual(idle);
expect(section.view.getByTestId("provider-update-status").textContent).toBe("Updated");
});
it("shows progress on Update when the sheet reopens mid-update", () => {
const section = mount(
installed(true),
available,
action({ current: runningUpdate(["downloading\n"]) }).value,
);
expect(progress(section)).toEqual(updating);
expect(section.view.queryByTestId("provider-update-status")).toBeNull();
});
it.each([
{ name: "still loading", state: { status: "loading" } },
{
name: "not installed",
state: { status: "ready", installation: { inspection: { status: "not_installed" } } },
},
{
name: "failing",
state: {
status: "ready",
installation: { inspection: { status: "error", message: "--version timed out" } },
},
},
{ name: "unreachable", state: { status: "error", message: "Host disconnected" } },
] satisfies { name: string; state: ProviderInstallationState }[])(
"shows progress on Update while the installation reads as $name",
({ state }) => {
const section = mount(
state,
{ status: "hidden" },
action({ current: runningUpdate() }).value,
);
// The inspection may show its own progress beside the Version row.
const button = section.view.getByRole("button", { name: "Updating..." });
expect(button.getAttribute("aria-disabled")).toBe("true");
expect(within(button).queryAllByRole("progressbar")).toHaveLength(1);
},
);
it("returns Update to rest when the host refuses the start", () => {
const section = mount(installed(true), available, action({ starting: true }).value);
expect(progress(section)).toEqual(updating);
section.rerender(available, action({ startError: "Busy" }).value);
expect(progress(section)).toEqual(idle);
expect(section.view.getByTestId("provider-update-status").textContent).toBe("Update failed");
});
});
it("shows why the host refused to start the update", async () => {
const section = mount(
installed(true),
available,
action({ startError: "Provider codex cannot update itself" }).value,
);
expect(section.view.getByTestId("provider-update-status").textContent).toBe("Update failed");
await expect
.element(section.view.getByText("Provider codex cannot update itself"))
.toBeVisible();
});
});
@@ -0,0 +1,448 @@
import { useCallback, useRef } from "react";
import { useTranslation } from "react-i18next";
import { ScrollView, Text, View } from "react-native";
import { StyleSheet, withUnistyles } from "react-native-unistyles";
import type {
ProviderInstallation,
ProviderInstallationUpdate,
ProviderInstallationUpdateCheck,
} from "@getpaseo/protocol/messages";
import { Button } from "@/components/ui/button";
import { ExternalLink } from "@/components/ui/external-link";
import { LoadingSpinner } from "@/components/ui/loading-spinner";
import { CODE_SURFACE_DATASET } from "@/styles/code-surface";
import { settingsStyles } from "@/styles/settings";
import type { Theme } from "@/styles/theme";
import { openExternalUrl } from "@/utils/open-external-url";
const ThemedLoadingSpinner = withUnistyles(LoadingSpinner);
const foregroundMutedColorMapping = (theme: Theme) => ({ color: theme.colors.foregroundMuted });
export type ProviderInstallationState =
| { status: "unsupported" }
| { status: "loading" }
| { status: "ready"; installation: ProviderInstallation | null }
| { status: "error"; message: string };
/**
* What the provider's update check knows. `hidden` until the provider is installed. A null
* `updateCheck` means the provider cannot check; the check only informs, and never gates Update.
*/
export type ProviderUpdatesState =
| { status: "hidden" }
| { status: "loading" }
| { status: "ready"; updateCheck: ProviderInstallationUpdateCheck | null }
| { status: "error"; message: string };
/** Running the provider's own update. Absent when the host cannot report updates. */
export interface ProviderUpdateAction {
/** The provider's latest update since the host started, or null. */
current: ProviderInstallationUpdate | null;
/** The request to start an update is in flight. */
starting: boolean;
/** Why the host did not start the update. */
startError: string | null;
start(): void;
}
export function ProviderInstallationSection({
state,
updates,
action,
}: {
state: ProviderInstallationState;
updates: ProviderUpdatesState;
action?: ProviderUpdateAction;
}) {
const { t } = useTranslation();
if (state.status === "unsupported") return null;
if (
state.status === "ready" &&
!state.installation?.inspection &&
!state.installation?.installUrl
)
return null;
const installation = state.status === "ready" ? state.installation : null;
const run = action ? readUpdateRun(action) : null;
// A running update keeps its row, so Update shows its progress whatever the inspection reads
// meanwhile; the binary may be mid-replacement.
const updating = action ? isUpdating(action) : false;
return (
<View style={settingsStyles.section} testID="provider-installation">
<View style={settingsStyles.sectionHeader}>
<Text style={settingsStyles.sectionHeaderTitle}>
{t("settings.providers.installation.title")}
</Text>
</View>
<View style={settingsStyles.card}>
<InstallationRow state={state} />
{installation?.inspection?.status === "installed" || updating ? (
<UpdatesRow
updates={updates}
updateUrl={installation?.updateUrl}
action={updating || installation?.canUpdate ? action : undefined}
/>
) : null}
{run ? <UpdateRunRow run={run} updateUrl={installation?.updateUrl} /> : null}
</View>
</View>
);
}
function InstallInstructionsLink({ installUrl }: { installUrl: string }) {
const { t } = useTranslation();
return (
<ExternalLink
href={installUrl}
label={t("settings.providers.installation.installInstructions")}
testID="provider-installation-install-instructions"
/>
);
}
function InstallationRow({ state }: { state: ProviderInstallationState }) {
const { t } = useTranslation();
const installation = state.status === "ready" ? state.installation : null;
const installUrl = installation?.installUrl;
const handleInstall = useCallback(() => {
if (installUrl) void openExternalUrl(installUrl);
}, [installUrl]);
if (state.status === "loading") {
return (
<View style={settingsStyles.row}>
<Text style={settingsStyles.rowTitle}>{t("settings.providers.installation.version")}</Text>
<View style={styles.trailing}>
<ThemedLoadingSpinner size="small" uniProps={foregroundMutedColorMapping} />
<Text style={styles.value}>{t("settings.providers.installation.checking")}</Text>
</View>
</View>
);
}
const inspection = installation?.inspection;
if (inspection?.status === "not_installed") {
return (
<View style={settingsStyles.row}>
<Text style={settingsStyles.rowTitle}>
{t("settings.providers.installation.notInstalled")}
</Text>
{installUrl ? (
<Button variant="outline" onPress={handleInstall}>
{t("settings.providers.installation.install")}
</Button>
) : null}
</View>
);
}
if (inspection?.status === "installed") {
return (
<View style={settingsStyles.row}>
<Text style={settingsStyles.rowTitle}>{t("settings.providers.installation.version")}</Text>
{inspection.version ? (
<Text
style={styles.version}
numberOfLines={1}
selectable
dataSet={CODE_SURFACE_DATASET}
testID="provider-installation-version"
>
{inspection.version}
</Text>
) : (
<Text style={styles.value}>{t("settings.providers.installation.installed")}</Text>
)}
</View>
);
}
// The installed state is unknown: the check failed, or the provider only links to a guide.
let message: string | null = null;
if (state.status === "error") message = state.message;
else if (inspection?.status === "error") message = inspection.message;
if (!message) {
return installUrl ? (
<View style={settingsStyles.row}>
<InstallInstructionsLink installUrl={installUrl} />
</View>
) : null;
}
return (
<View style={settingsStyles.row}>
<View style={settingsStyles.rowContent}>
<Text style={settingsStyles.rowTitle}>{t("settings.providers.installation.failed")}</Text>
<Text style={settingsStyles.rowHint}>{message}</Text>
{installUrl ? (
<View style={styles.link}>
<InstallInstructionsLink installUrl={installUrl} />
</View>
) : null}
</View>
</View>
);
}
/**
* The update the provider offers, with what its check knows beside it. Update, or the update
* instructions, stay in place whatever the check says: an answer can be an hour old, and the
* provider's own updater reports when there is nothing newer.
*/
function UpdatesRow({
updates,
updateUrl,
action,
}: {
updates: ProviderUpdatesState;
updateUrl: string | undefined;
/** Present when the provider runs its own update. */
action: ProviderUpdateAction | undefined;
}) {
const { t } = useTranslation();
const updateCheck = updates.status === "ready" ? updates.updateCheck : null;
const offersUpdate = Boolean(action || updateUrl);
// With nothing to offer, the row waits until the check has something to say.
if (!offersUpdate && !updateCheck && updates.status !== "error") return null;
return (
<View style={[settingsStyles.row, settingsStyles.rowBorder]} testID="provider-updates">
<View style={settingsStyles.rowContent}>
<Text style={settingsStyles.rowTitle}>
{updateCheck?.status === "available"
? t("settings.providers.installation.updateAvailable")
: t("settings.providers.installation.updates")}
</Text>
<UpdateCheckSummary updates={updates} />
</View>
<UpdateButton action={action} updateUrl={updateUrl} />
</View>
);
}
function UpdateCheckSummary({ updates }: { updates: ProviderUpdatesState }) {
const { t } = useTranslation();
if (updates.status === "loading") {
return (
<View style={styles.trailing}>
<ThemedLoadingSpinner size="small" uniProps={foregroundMutedColorMapping} />
<Text style={settingsStyles.rowHint}>{t("settings.providers.installation.checking")}</Text>
</View>
);
}
if (updates.status === "hidden") return null;
const updateCheck = updates.status === "ready" ? updates.updateCheck : null;
if (updates.status === "ready" && !updateCheck) return null;
if (updateCheck?.status === "current") {
return (
<Text style={settingsStyles.rowHint} testID="provider-updates-current">
{t("settings.providers.installation.upToDate")}
</Text>
);
}
if (updateCheck?.status === "available") {
// Versions are opaque; drop repeats so each one keys its own line.
const versions = [...new Set(updateCheck.versions ?? [])];
return (
<>
{versions.map((version) => (
<Text
key={version}
style={styles.availableVersion}
selectable
dataSet={CODE_SURFACE_DATASET}
testID="provider-updates-version"
>
{version}
</Text>
))}
{updateCheck.message ? (
<Text style={settingsStyles.rowHint}>{updateCheck.message}</Text>
) : null}
</>
);
}
// A check that threw, timed out or could not tell is never shown as up to date.
const message = updates.status === "error" ? updates.message : updateCheck?.message;
return (
<>
<Text style={settingsStyles.rowHint} testID="provider-updates-unchecked">
{t("settings.providers.installation.updatesFailed")}
</Text>
{message ? <Text style={settingsStyles.rowHint}>{message}</Text> : null}
</>
);
}
function isUpdating(action: ProviderUpdateAction): boolean {
return action.starting || action.current?.operation.status === "running";
}
/**
* Update runs the provider's updater; without one, the provider's update guide opens. The button
* carries the update's progress from the tap until it settles.
*/
function UpdateButton({
action,
updateUrl,
}: {
action: ProviderUpdateAction | undefined;
updateUrl: string | undefined;
}) {
const { t } = useTranslation();
const handleOpenInstructions = useCallback(() => {
if (updateUrl) void openExternalUrl(updateUrl);
}, [updateUrl]);
if (action)
return (
<Button
variant="outline"
onPress={action.start}
loading={isUpdating(action)}
testID="provider-update-start"
>
{isUpdating(action)
? t("settings.providers.installation.updating")
: t("settings.providers.installation.update")}
</Button>
);
if (!updateUrl) return null;
return (
<Button variant="outline" onPress={handleOpenInstructions}>
{t("settings.providers.installation.updateInstructions")}
</Button>
);
}
type UpdateRun =
| { status: "running"; update: ProviderInstallationUpdate }
| { status: "succeeded" | "failed"; update: ProviderInstallationUpdate }
| { status: "refused"; message: string };
/**
* What the update's row shows, or null for nothing. While the update starts or runs, Update shows
* its progress and the row holds only the output so far. A new start clears the previous result.
*/
function readUpdateRun(action: ProviderUpdateAction): UpdateRun | null {
const update = action.current;
if (isUpdating(action)) {
return update?.operation.status === "running" && update.output.length > 0
? { status: "running", update }
: null;
}
if (action.startError) return { status: "refused", message: action.startError };
if (!update || update.operation.status === "running") return null;
return { status: update.operation.status, update };
}
function UpdateRunRow({ run, updateUrl }: { run: UpdateRun; updateUrl: string | undefined }) {
const { t } = useTranslation();
const scroll = useRef<ScrollView>(null);
const followOutput = useCallback(() => scroll.current?.scrollToEnd({ animated: false }), []);
const update = run.status === "refused" ? null : run.update;
const output = update?.output.map((entry) => entry.text).join("") ?? "";
let message: string | undefined;
if (run.status === "refused") message = run.message;
else if (run.update.operation.status !== "running") message = run.update.operation.message;
return (
<View style={[settingsStyles.row, settingsStyles.rowBorder]} testID="provider-update-run">
<View style={settingsStyles.rowContent}>
{run.status === "running" ? null : (
<Text style={settingsStyles.rowTitle} testID="provider-update-status">
{run.status === "succeeded"
? t("settings.providers.installation.updated")
: t("settings.providers.installation.updateFailed")}
</Text>
)}
{message ? (
<Text style={settingsStyles.rowHint} selectable testID="provider-update-message">
{message}
</Text>
) : null}
{output ? (
<ScrollView
ref={scroll}
style={
run.status === "running" ? styles.output : [styles.output, styles.outputAfterResult]
}
contentContainerStyle={styles.outputContent}
onContentSizeChange={followOutput}
// Android scrolls a ScrollView nested in the provider sheet only with this flag.
nestedScrollEnabled
>
{update?.truncated ? (
<Text style={styles.outputNote}>
{t("settings.providers.installation.outputTruncated")}
</Text>
) : null}
<Text
style={styles.outputText}
selectable
dataSet={CODE_SURFACE_DATASET}
testID="provider-update-output"
>
{output}
</Text>
</ScrollView>
) : null}
{(run.status === "failed" || run.status === "refused") && updateUrl ? (
<View style={styles.link}>
<ExternalLink
href={updateUrl}
label={t("settings.providers.installation.updateInstructions")}
/>
</View>
) : null}
</View>
</View>
);
}
const styles = StyleSheet.create((theme) => ({
output: {
maxHeight: 240,
borderRadius: theme.borderRadius.md,
backgroundColor: theme.colors.surface0,
},
outputAfterResult: {
marginTop: theme.spacing[2],
},
outputContent: {
padding: theme.spacing[3],
},
outputText: {
fontFamily: theme.fontFamily.mono,
fontSize: theme.fontSize.code,
lineHeight: 20,
color: theme.colors.foreground,
},
outputNote: {
marginBottom: theme.spacing[1],
fontSize: theme.fontSize.sm,
color: theme.colors.foregroundMuted,
},
trailing: {
flexDirection: "row",
alignItems: "center",
gap: theme.spacing[2],
},
value: {
color: theme.colors.foregroundMuted,
fontSize: theme.fontSize.sm,
},
version: {
flexShrink: 1,
marginLeft: theme.spacing[3],
fontFamily: theme.fontFamily.mono,
fontSize: theme.fontSize.code,
color: theme.colors.foregroundMuted,
},
availableVersion: {
marginTop: theme.spacing[1],
fontFamily: theme.fontFamily.mono,
fontSize: theme.fontSize.code,
color: theme.colors.foregroundMuted,
},
link: {
flexDirection: "row",
marginTop: theme.spacing[1],
},
}));
@@ -0,0 +1,195 @@
import { useMutation, useQueryClient } from "@tanstack/react-query";
import { useCallback, useEffect, useState } from "react";
import { useTranslation } from "react-i18next";
import type { ProviderInstallationUpdate } from "@getpaseo/protocol/messages";
import { useFetchQuery } from "@/data/query";
import { useHostFeature } from "@/runtime/host-features";
import { useHostRuntimeClient } from "@/runtime/host-runtime";
import type {
ProviderInstallationState,
ProviderUpdateAction,
ProviderUpdatesState,
} from "./provider-installation-section";
import { applyProviderUpdateProgress } from "./provider-update-progress";
export interface ProviderInstallationRead {
state: ProviderInstallationState;
updates: ProviderUpdatesState;
/** Absent when the host cannot report provider installations. */
action: ProviderUpdateAction | undefined;
/** Ask the provider again, skipping the host's caches. */
refresh: () => void;
/** A refresh is in flight. The last answers stay on screen until the new ones arrive. */
refreshing: boolean;
}
/**
* Reads a provider's installation from hosts that advertise `providerInstallation`. The update
* check is a separate request that starts once the provider reports itself installed, so the
* installed version never waits on it.
*/
export function useProviderInstallation(input: {
serverId: string;
provider: string;
visible: boolean;
}): ProviderInstallationRead {
const { serverId, provider, visible } = input;
const supported = useHostFeature(serverId, "providerInstallation");
const client = useHostRuntimeClient(serverId);
const queryClient = useQueryClient();
const { t } = useTranslation();
const enabled = supported && visible && Boolean(client);
const installationKey = ["provider-installation", serverId, provider] as const;
const updatesKey = ["provider-updates", serverId, provider] as const;
const inspect = useCallback(
async (refresh: boolean) => {
if (!client) throw new Error(t("workspace.terminal.hostDisconnected"));
const result = await client.inspectProviderInstallation(provider, { refresh });
if (result.error) throw new Error(result.error);
return result.installation;
},
[client, provider, t],
);
const checkForUpdates = useCallback(
async (refresh: boolean) => {
if (!client) throw new Error(t("workspace.terminal.hostDisconnected"));
const result = await client.checkProviderUpdates(provider, { refresh });
if (result.error) throw new Error(result.error);
return result.updateCheck;
},
[client, provider, t],
);
// The host caches both answers, so reading on every open is cheap.
const installationQuery = useFetchQuery({
queryKey: installationKey,
queryFn: () => inspect(false),
enabled,
dataShape: "value",
staleTimeMs: 0,
});
const installed = installationQuery.data?.inspection?.status === "installed";
const updatesQuery = useFetchQuery({
queryKey: updatesKey,
queryFn: () => checkForUpdates(false),
enabled: enabled && installed,
dataShape: "value",
staleTimeMs: 0,
});
// A refresh runs through the queries so its answer or its failure is what the screen shows.
// `staleTime: 0` overrides the app default so the request always goes out.
const refreshInstallation = useMutation({
mutationFn: () =>
queryClient.fetchQuery({
queryKey: installationKey,
queryFn: () => inspect(true),
staleTime: 0,
}),
});
const refreshUpdates = useMutation({
mutationFn: () =>
queryClient.fetchQuery({
queryKey: updatesKey,
queryFn: () => checkForUpdates(true),
staleTime: 0,
}),
});
// The host owns the update; this view follows it while open and catches up on reopen.
const [currentUpdate, setCurrentUpdate] = useState<ProviderInstallationUpdate | null>(null);
useEffect(() => {
if (!enabled || !client) return;
const subscription = client.observeProviderUpdates(provider);
// The update this view saw running. Its success arrives as live progress, or as the snapshot
// a reconnect delivers when the progress was missed; either way the host dropped its cached
// answers, so read the new version and update state.
let runningId: string | null = null;
const follow = (operation: ProviderInstallationUpdate["operation"] | undefined) => {
if (!operation) return;
if (operation.status === "running") {
runningId = operation.id;
return;
}
if (operation.id !== runningId) return;
runningId = null;
if (operation.status !== "succeeded") return;
void queryClient.invalidateQueries({
queryKey: ["provider-installation", serverId, provider],
});
void queryClient.invalidateQueries({ queryKey: ["provider-updates", serverId, provider] });
};
const detach = subscription.subscribe({
snapshot: (response) => {
setCurrentUpdate(response.update);
follow(response.update?.operation);
},
update: (message) => {
if (message.type === "provider.installation.update.cleared") {
const { operationId } = message.payload;
setCurrentUpdate((current) => (current?.operation.id === operationId ? null : current));
return;
}
if (message.type !== "provider.installation.update.progress") return;
setCurrentUpdate((current) => applyProviderUpdateProgress(current, message.payload));
follow(message.payload.operation);
},
error: (failure) => console.warn("Failed to observe provider updates", failure),
});
return () => {
detach();
void subscription
.release()
.catch((failure) => console.warn("Failed to release provider update observation", failure));
};
}, [client, enabled, provider, queryClient, serverId]);
const startUpdate = useMutation({
mutationFn: async () => {
if (!client) throw new Error(t("workspace.terminal.hostDisconnected"));
const result = await client.updateProvider(provider);
if (result.error) throw new Error(result.error);
return result.update;
},
onSuccess: (update) => {
if (!update) return;
// Progress for this operation may already have arrived; keep the further-along copy.
setCurrentUpdate((current) =>
current?.operation.id === update.operation.id ? current : update,
);
},
});
const { mutate: mutateStartUpdate } = startUpdate;
const start = useCallback(() => mutateStartUpdate(), [mutateStartUpdate]);
const action: ProviderUpdateAction | undefined = supported
? {
current: currentUpdate,
starting: startUpdate.isPending,
startError: startUpdate.error?.message ?? null,
start,
}
: undefined;
const { mutate: mutateInstallation } = refreshInstallation;
const { mutate: mutateUpdates } = refreshUpdates;
const refresh = useCallback(() => {
if (!supported || !client) return;
mutateInstallation();
if (installed) mutateUpdates();
}, [client, installed, mutateInstallation, mutateUpdates, supported]);
let state: ProviderInstallationState;
if (!supported) state = { status: "unsupported" };
else if (installationQuery.isPending) state = { status: "loading" };
else if (installationQuery.isError)
state = { status: "error", message: installationQuery.error.message };
else state = { status: "ready", installation: installationQuery.data ?? null };
let updates: ProviderUpdatesState;
if (!supported || !installed) updates = { status: "hidden" };
else if (updatesQuery.isPending) updates = { status: "loading" };
else if (updatesQuery.isError) updates = { status: "error", message: updatesQuery.error.message };
else updates = { status: "ready", updateCheck: updatesQuery.data ?? null };
const refreshing = refreshInstallation.isPending || refreshUpdates.isPending;
return { state, updates, action, refresh, refreshing };
}
@@ -1,5 +1,5 @@
import { useCallback } from "react";
import { ProviderDiagnosticSheet } from "@/components/provider-diagnostic-sheet";
import { ProviderDetailSheet } from "@/provider-settings";
import { OverlayLayerProvider } from "@/lib/overlay-root";
import { useProviderSettingsStore } from "@/stores/provider-settings-store";
@@ -20,7 +20,7 @@ export function ProviderSettingsHost() {
return (
<OverlayLayerProvider layer={overlayParentLayer}>
<ProviderDiagnosticSheet
<ProviderDetailSheet
key={`${serverId}:${provider}`}
provider={provider}
serverId={serverId}
@@ -0,0 +1,48 @@
import { describe, expect, it } from "vitest";
import type { ProviderInstallationUpdateProgress } from "@getpaseo/protocol/messages";
import { applyProviderUpdateProgress } from "./provider-update-progress";
const running = {
status: "running",
id: "update-1",
startedAt: "2026-11-13T00:00:00.000Z",
} as const;
function progress(...texts: string[]): ProviderInstallationUpdateProgress {
return {
provider: "codex",
operation: running,
output: texts.map((text) => ({ type: "stdout", text })),
};
}
describe("applyProviderUpdateProgress", () => {
it("appends output for the same update", () => {
const first = applyProviderUpdateProgress(null, progress("a"), { outputLimit: 10 });
const second = applyProviderUpdateProgress(first, progress("b"), { outputLimit: 10 });
expect(second.output.map((entry) => entry.text)).toEqual(["a", "b"]);
expect(second.truncated).toBeUndefined();
});
it("drops the oldest output beyond the limit and marks the update truncated", () => {
let update = applyProviderUpdateProgress(null, progress("12345"), { outputLimit: 8 });
update = applyProviderUpdateProgress(update, progress("6789"), { outputLimit: 8 });
expect(update.output.map((entry) => entry.text)).toEqual(["6789"]);
expect(update.truncated).toBe(true);
update = applyProviderUpdateProgress(update, progress("abcdefghij"), { outputLimit: 8 });
expect(update.output.map((entry) => entry.text)).toEqual(["cdefghij"]);
expect(update.truncated).toBe(true);
});
it("starts a new update empty", () => {
const first = applyProviderUpdateProgress(null, progress("123456789"), { outputLimit: 4 });
const next = applyProviderUpdateProgress(
first,
{ ...progress("x"), operation: { ...running, id: "update-2" } },
{ outputLimit: 4 },
);
expect(next.output.map((entry) => entry.text)).toEqual(["x"]);
expect(next.truncated).toBeUndefined();
});
});
@@ -0,0 +1,38 @@
import type {
ProviderInstallationUpdate,
ProviderInstallationUpdateOutput,
ProviderInstallationUpdateProgress,
} from "@getpaseo/protocol/messages";
/** Characters of update output the app keeps, matching what the daemon retains. */
export const PROVIDER_UPDATE_OUTPUT_LIMIT = 64 * 1024;
/**
* Folds a progress message into the update it belongs to; a new operation starts empty. Output
* beyond `outputLimit` characters drops oldest first and marks the update truncated, so a noisy
* updater cannot grow the screen's memory while it stays open.
*/
export function applyProviderUpdateProgress(
current: ProviderInstallationUpdate | null,
progress: ProviderInstallationUpdateProgress,
options: { outputLimit: number } = { outputLimit: PROVIDER_UPDATE_OUTPUT_LIMIT },
): ProviderInstallationUpdate {
const previous = current?.operation.id === progress.operation.id ? current : null;
const limit = options.outputLimit;
const output: ProviderInstallationUpdateOutput[] = [
...(previous?.output ?? []),
...progress.output,
];
let length = output.reduce((total, entry) => total + entry.text.length, 0);
let truncated = previous?.truncated ?? false;
while (length > limit && output.length > 1) {
length -= output.shift()!.text.length;
truncated = true;
}
const last = output.at(-1);
if (last && last.text.length > limit) {
output[output.length - 1] = { type: last.type, text: last.text.slice(-limit) };
truncated = true;
}
return { operation: progress.operation, output, ...(truncated ? { truncated: true } : {}) };
}
@@ -0,0 +1,60 @@
import { Plus } from "lucide-react-native";
import { useCallback } from "react";
import { Text, View, type PressableStateCallbackType } from "react-native";
import { StyleSheet, withUnistyles } from "react-native-unistyles";
import { mutedIconColorMapping } from "@/components/ui/icon-color";
import { PressHighlight } from "@/components/ui/press-highlight";
import { ICON_SIZE } from "@/styles/theme";
import { useSettingsRowLayout } from "./row-density";
const ThemedPlus = withUnistyles(Plus);
type HoverState = PressableStateCallbackType & { hovered?: boolean };
/**
* The last row of a card that lists things, adding one more. Quiet, so the list reads first: a
* muted plus in the rows' leading slot and a muted label on the labels' rail.
*/
export function SettingsAddRow({
label,
onPress,
testID,
}: {
label: string;
onPress: () => void;
testID?: string;
}) {
const layout = useSettingsRowLayout();
const rowStyle = useCallback(
({ hovered, pressed }: HoverState) => [
layout.row,
styles.row,
hovered && styles.hovered,
pressed && styles.pressed,
],
[layout],
);
return (
<PressHighlight
accessibilityRole="button"
accessibilityLabel={label}
onPress={onPress}
style={rowStyle}
highlightStyle={styles.pressed}
testID={testID}
>
<View style={styles.leading}>
<ThemedPlus size={ICON_SIZE.md} uniProps={mutedIconColorMapping} />
</View>
<Text style={[layout.title, styles.label]}>{label}</Text>
</PressHighlight>
);
}
const styles = StyleSheet.create((theme) => ({
row: { justifyContent: "flex-start" },
leading: { marginRight: theme.spacing[3], alignItems: "center", justifyContent: "center" },
label: { color: theme.colors.foregroundMuted },
hovered: { backgroundColor: theme.colors.surface2 },
pressed: { backgroundColor: theme.colors.surface3 },
}));
@@ -0,0 +1,86 @@
import { ArrowLeft } from "lucide-react-native";
import type { ReactNode } from "react";
import { Text, View } from "react-native";
import { StyleSheet } from "react-native-unistyles";
import { Button } from "@/components/ui/button";
/**
* "Back to …" above a settings detail page on wide layouts, where the page has no header of its
* own. The ghost button drops its padding so the arrow sits on the content's leading rail.
*/
export function SettingsBackLink({
label,
onPress,
testID,
}: {
label: string;
onPress: () => void;
testID?: string;
}) {
return (
<Button
testID={testID}
accessibilityLabel={label}
onPress={onPress}
variant="ghost"
leftIcon={ArrowLeft}
style={styles.backLink}
>
{label}
</Button>
);
}
/**
* The top of a settings detail page: "Back to …" when the page has no header of its own, then the
* icon and name the page is about, with an optional action after the name.
*/
export function SettingsDetailHeader({
back,
icon,
title,
trailing,
titleTestID,
}: {
back?: { label: string; onPress: () => void; testID?: string };
icon: ReactNode;
title: string;
trailing?: ReactNode;
titleTestID?: string;
}) {
return (
<View style={styles.header}>
{back ? <SettingsBackLink {...back} /> : null}
<View style={styles.titleRow}>
{icon}
<Text style={styles.title} numberOfLines={1} testID={titleTestID}>
{title}
</Text>
{trailing}
</View>
</View>
);
}
const styles = StyleSheet.create((theme) => ({
backLink: {
alignSelf: "flex-start",
paddingHorizontal: 0,
},
header: {
gap: theme.spacing[2],
marginBottom: theme.spacing[4],
},
titleRow: {
marginTop: theme.spacing[2],
flexDirection: "row",
alignItems: "center",
gap: theme.spacing[3],
},
title: {
color: theme.colors.foreground,
fontSize: theme.fontSize.base,
fontWeight: theme.fontWeight.medium,
flexShrink: 1,
},
}));
@@ -1,12 +1,16 @@
import type { ReactNode } from "react";
import { SettingsRowHeader } from "./row-header";
import { SettingsRowHeader, type SettingsRowHintStatus } from "./row-header";
interface SettingsDetailRowProps {
label: string;
/** An icon before the label, such as the thing the row opens. */
leading?: ReactNode;
/** Shown beside the label, such as a badge. */
labelAccessory?: ReactNode;
/** A line under the label saying what the row leads to. */
hint?: string;
/** Marks the hint as work under way, a fault, or a value still loading. */
hintStatus?: SettingsRowHintStatus;
/** What the detail is set to, so the row says it without being opened. */
summary?: string;
onPress: () => void;
@@ -14,6 +18,10 @@ interface SettingsDetailRowProps {
disabled?: boolean;
/** Opens a page outside the app; an outward arrow replaces the chevron. */
external?: boolean;
/** A control acting on the row's subject in place, such as a switch, before the chevron. */
control?: ReactNode;
/** Names the row for assistive tech when the label alone does not say where it leads. */
accessibilityLabel?: string;
testID?: string;
}
+12 -1
View File
@@ -30,12 +30,17 @@ export { SettingsGroup } from "./headings/settings-group";
export { SettingsSection } from "./headings/settings-section";
export { SettingsCollapsibleRow } from "./collapsible-row";
export { SettingsDetailRow } from "./detail-row";
export type { SettingsRowHintStatus } from "./row-header";
export { SettingsAddRow } from "./add-row";
export { SettingsBackLink, SettingsDetailHeader } from "./detail-header";
export { SettingsInfoTip } from "./headings/settings-info-tip";
export { MenuSettingsRows } from "./row-density";
/** What app screens can add to a plugin-facing row: an accessory beside the label, such as an info tip. */
interface AppRowExtras {
labelAccessory?: ReactNode;
/** An icon before the label, such as the thing the row is about. */
leading?: ReactNode;
}
interface AppSettingsRowProps extends Omit<SettingsRowProps, "hint">, AppRowExtras {
@@ -59,6 +64,7 @@ export function SettingsCard({ children, testID }: { children: ReactNode; testID
export function SettingsRow({
label,
leading,
labelAccessory,
hint,
error,
@@ -71,6 +77,7 @@ export function SettingsRow({
const accessoryTitleStyle = useMemo(() => [layout.title, styles.accessoryLabel], [layout]);
return (
<View style={rowStyle} testID={testID}>
{leading ? <View style={styles.leading}>{leading}</View> : null}
<View style={styles.label}>
{labelAccessory ? (
<View style={styles.labelRow}>
@@ -208,7 +215,11 @@ export function SettingsAction({ actionLabel, onPress, disabled, ...row }: Setti
}
const styles = StyleSheet.create((theme) => ({
compactRow: { flexWrap: "wrap", gap: theme.spacing[3] },
// A control that wraps under the label gets space above it. Across the row, the leading slot and
// the label already carry their own margins, so a column gap would double them.
compactRow: { flexWrap: "wrap", rowGap: theme.spacing[3] },
// The same leading slot as `SettingsRowHeader`, so icons and labels share rails across row kinds.
leading: { marginRight: theme.spacing[3], alignItems: "center", justifyContent: "center" },
label: { flexGrow: 1, flexShrink: 1, flexBasis: 160, marginRight: theme.spacing[3] },
labelRow: {
flexDirection: "row",
@@ -2,7 +2,12 @@ import React, { act } from "react";
import { createRoot, type Root } from "react-dom/client";
import { afterEach, describe, expect, it } from "vitest";
import { Button } from "@/components/ui/button";
import { SettingsCard, SettingsCollapsibleRow, SettingsRow } from "@/components/settings";
import {
SettingsCard,
SettingsCollapsibleRow,
SettingsDetailRow,
SettingsRow,
} from "@/components/settings";
let root: Root | null = null;
let container: HTMLDivElement | null = null;
@@ -14,6 +19,8 @@ afterEach(() => {
container = null;
});
function openNothing() {}
function mountRows() {
container = document.createElement("div");
document.body.appendChild(container);
@@ -26,6 +33,7 @@ function mountRows() {
Download
</Button>
</SettingsRow>
<SettingsDetailRow label="Opens a page" onPress={openNothing} testID="detail-row" />
<SettingsCollapsibleRow label="Group" defaultExpanded testID="group">
<SettingsRow label="Nested with a button" testID="nested-with-button">
<Button variant="outline" testID="nested-button">
@@ -66,6 +74,13 @@ describe("settings row density", () => {
expect(heightOf("group-toggle")).toBeGreaterThan(heightOf("nested-without-button"));
});
it("keeps a row that opens something as tall as a row holding a control", () => {
mountRows();
expect(heightOf("detail-row")).toBe(heightOf("card-row"));
expect(heightOf("group-toggle")).toBe(heightOf("card-row"));
});
it("sizes nested text and controls one step below card rows", () => {
mountRows();
@@ -27,6 +27,11 @@ export function MenuSettingsRows({ children }: { children: ReactNode }) {
export interface SettingsRowLayout {
row: StyleProp<ViewStyle>;
/**
* A row as tall as one holding a control of `controlSize`, whether or not it holds one. In a menu
* it keeps the menu's row height.
*/
controlRow: StyleProp<ViewStyle>;
title: StyleProp<TextStyle>;
hint: StyleProp<TextStyle>;
/** The size of the controls in the row's trailing slot. */
@@ -38,6 +43,7 @@ function layoutFor(placement: RowPlacement): SettingsRowLayout {
case "nested":
return {
row: [settingsStyles.row, styles.nestedRow],
controlRow: [settingsStyles.row, styles.nestedRow],
title: [settingsStyles.rowTitle, styles.nestedText],
hint: [settingsStyles.rowHint, styles.nestedText],
controlSize: "sm",
@@ -45,6 +51,7 @@ function layoutFor(placement: RowPlacement): SettingsRowLayout {
case "menu":
return {
row: [settingsStyles.row, styles.menuRow],
controlRow: [settingsStyles.row, styles.menuRow],
title: settingsStyles.rowTitle,
hint: settingsStyles.rowHint,
controlSize: "md",
@@ -52,6 +59,7 @@ function layoutFor(placement: RowPlacement): SettingsRowLayout {
case "card":
return {
row: settingsStyles.row,
controlRow: [settingsStyles.row, styles.cardControlRow],
title: settingsStyles.rowTitle,
hint: settingsStyles.rowHint,
controlSize: "md",
@@ -66,6 +74,9 @@ export function useSettingsRowLayout(): SettingsRowLayout {
}
const styles = StyleSheet.create((theme) => ({
cardControlRow: {
minHeight: mapLayout(CONTROL_HEIGHTS.md, (height) => height + theme.spacing[4] * 2),
},
// Every nested row is as tall as one holding an `sm` control, so rows with and without a
// trailing button line up.
nestedRow: {
@@ -1,25 +1,36 @@
import { ChevronRight } from "lucide-react-native";
import { useCallback, useMemo, type ReactNode } from "react";
import { Text, View, type AccessibilityState, type PressableStateCallbackType } from "react-native";
import { useCallback, useMemo, useState, type ReactNode } from "react";
import { Text, View, type AccessibilityState } from "react-native";
import { StyleSheet, withUnistyles } from "react-native-unistyles";
import { ControlSizeProvider } from "@/components/ui/control-size";
import { ExternalLinkLabel } from "@/components/ui/external-link";
import { mutedIconColorMapping } from "@/components/ui/icon-color";
import { LoadingSpinner } from "@/components/ui/loading-spinner";
import { PressHighlight } from "@/components/ui/press-highlight";
import { SkeletonPulse, useSkeletonPulse } from "@/components/ui/skeleton";
import { settingsStyles } from "@/styles/settings";
import { ICON_SIZE, type Theme } from "@/styles/theme";
import { useSettingsRowLayout } from "./row-density";
import { useSettingsRowLayout, type SettingsRowLayout } from "./row-density";
const ThemedChevron = withUnistyles(ChevronRight);
const ThemedLoadingSpinner = withUnistyles(LoadingSpinner);
const hoveredIconColorMapping = (theme: Theme) => ({ color: theme.colors.foreground });
type HoverState = PressableStateCallbackType & { hovered?: boolean };
/**
* What the hint reports beyond its words: work under way (a leading spinner), a fault (a leading
* red dot and red text), or a value still loading (a placeholder the height of the line).
*/
export type SettingsRowHintStatus = "busy" | "error" | "pending";
export interface SettingsRowHeaderProps {
label: string;
/** An icon before the label, such as the thing the row opens. */
leading?: ReactNode;
/** Shown beside the label, such as a badge. */
labelAccessory?: ReactNode;
/** A line under the label saying what the row leads to. */
hint?: string;
hintStatus?: SettingsRowHintStatus;
/** A short status shown before the chevron. */
summary?: string;
onPress: () => void;
@@ -28,6 +39,10 @@ export interface SettingsRowHeaderProps {
expanded?: boolean;
/** The row leaves the app, such as to a docs page: the summary and an outward arrow are drawn as an external link in place of the chevron. */
external?: boolean;
/** A control acting on the row's subject in place, such as a switch, before the chevron. */
control?: ReactNode;
/** Names the row for assistive tech when the label alone does not say where it leads. */
accessibilityLabel?: string;
accessibilityState?: AccessibilityState;
/** Props React Native Web does not derive from `accessibilityState`, such as `aria-expanded`. */
webAccessibilityProps?: Record<string, unknown> | null;
@@ -38,81 +53,209 @@ export interface SettingsRowHeaderProps {
* The pressable line shared by settings rows that lead somewhere: a label, an optional summary and
* a trailing chevron. A collapsible row turns the chevron down; a row that opens a sheet keeps it
* pointing right.
*
* The press target is a button laid under the row's content rather than wrapped around it, so a
* control in the row is the button's sibling: a switch inside a button is invalid markup, and keys
* pressed on the switch would also press the row. Everything drawn over the button lets presses
* through to it. The label, icon and summary stay out of the accessibility tree, where the button's
* label already names the row; the hint stays readable, since it carries the row's state.
* Hover is tracked on the row itself, so it holds while the pointer is over the control.
*
* The row is as tall as one holding a control whether or not it holds one, so a list where only
* some rows carry a switch keeps one row height.
*/
export function SettingsRowHeader({
label,
leading,
labelAccessory,
hint,
hintStatus,
summary,
onPress,
disabled,
expanded = false,
external = false,
control,
accessibilityLabel,
accessibilityState,
webAccessibilityProps,
testID,
}: SettingsRowHeaderProps) {
const layout = useSettingsRowLayout();
const rowStyle = useCallback(
({ hovered }: HoverState) => [layout.row, !disabled && hovered && styles.hovered],
[disabled, layout],
);
const [pointerOver, setPointerOver] = useState(false);
const handlePointerEnter = useCallback(() => setPointerOver(true), []);
const handlePointerLeave = useCallback(() => setPointerOver(false), []);
const hovered = pointerOver && !disabled;
const rowStyle = useMemo(() => [layout.controlRow, hovered && styles.hovered], [hovered, layout]);
const chevronStyle = useMemo(
() => [styles.chevron, expanded && styles.chevronExpanded],
[expanded],
);
return (
<PressHighlight
{...webAccessibilityProps}
accessibilityRole={external ? "link" : "button"}
accessibilityLabel={summary ? `${label}, ${summary}` : label}
accessibilityState={accessibilityState}
disabled={disabled}
onPress={onPress}
<View
style={rowStyle}
highlightStyle={styles.pressed}
onPointerEnter={handlePointerEnter}
onPointerLeave={handlePointerLeave}
testID={testID}
>
{({ hovered }: HoverState) => (
<>
<View style={settingsStyles.rowContent}>
{labelAccessory ? (
<View style={styles.labelRow}>
<Text style={layout.title}>{label}</Text>
{labelAccessory}
<PressHighlight
{...webAccessibilityProps}
accessibilityRole={external ? "link" : "button"}
accessibilityLabel={accessibilityLabel ?? (summary ? `${label}, ${summary}` : label)}
accessibilityState={accessibilityState}
disabled={disabled}
onPress={onPress}
style={styles.pressTarget}
highlightStyle={styles.pressed}
/>
{leading ? (
<View style={[styles.leading, styles.passThrough]} {...HIDDEN_FROM_ASSISTIVE_TECH}>
{leading}
</View>
) : null}
<View style={[settingsStyles.rowContent, styles.passThrough]}>
<View style={labelAccessory ? styles.labelRow : undefined} {...HIDDEN_FROM_ASSISTIVE_TECH}>
<Text style={layout.title}>{label}</Text>
{labelAccessory}
</View>
{hintStatus ? (
<RowHintLine hint={hint} status={hintStatus} hintStyle={layout.hint} />
) : null}
{hint && !hintStatus ? <Text style={layout.hint}>{hint}</Text> : null}
</View>
{control ? (
<View style={styles.control}>
<ControlSizeProvider size={layout.controlSize}>{control}</ControlSizeProvider>
</View>
) : null}
<View style={[styles.trailing, styles.passThrough]} {...HIDDEN_FROM_ASSISTIVE_TECH}>
{external ? (
// Drawn the same as a section header's docs link, so the two read as one thing.
<ExternalLinkLabel hovered={hovered}>{summary}</ExternalLinkLabel>
) : (
<>
{summary ? (
<Text style={styles.summary} numberOfLines={1}>
{summary}
</Text>
) : null}
{disabled ? null : (
<View style={chevronStyle}>
<ThemedChevron
size={ICON_SIZE.sm}
uniProps={hovered ? hoveredIconColorMapping : mutedIconColorMapping}
/>
</View>
) : (
<Text style={layout.title}>{label}</Text>
)}
{hint ? <Text style={layout.hint}>{hint}</Text> : null}
</View>
{external ? (
// Drawn the same as a section header's docs link, so the two read as one thing.
<ExternalLinkLabel hovered={hovered}>{summary}</ExternalLinkLabel>
) : (
<>
{summary ? (
<Text style={styles.summary} numberOfLines={1}>
{summary}
</Text>
) : null}
{disabled ? null : (
<View style={chevronStyle}>
<ThemedChevron
size={ICON_SIZE.sm}
uniProps={hovered ? hoveredIconColorMapping : mutedIconColorMapping}
/>
</View>
)}
</>
)}
</>
)}
</PressHighlight>
</>
)}
</View>
</View>
);
}
const HIDDEN_FROM_ASSISTIVE_TECH = {
accessibilityElementsHidden: true,
importantForAccessibility: "no-hide-descendants",
"aria-hidden": true,
} as const;
/**
* The hint with its status mark. The line keeps the hint's own height in every status, so a row
* does not move when its value arrives or its work starts. A long error is cut to the line; the
* row's detail says it in full.
*/
function RowHintLine({
hint,
status,
hintStyle,
}: {
hint: string | undefined;
status: SettingsRowHintStatus;
hintStyle: SettingsRowLayout["hint"];
}) {
const textStyle = useMemo(
() => [hintStyle, styles.hintText, status === "error" && styles.hintError],
[hintStyle, status],
);
if (status === "pending") {
return (
<View style={styles.hintLine}>
{/* A blank line of hint text holds the height; the placeholder sits over it. */}
<Text style={textStyle}> </Text>
<HintPlaceholder />
</View>
);
}
return (
<View style={styles.hintLine}>
{status === "busy" ? (
<ThemedLoadingSpinner size={14} uniProps={mutedIconColorMapping} />
) : (
<View style={styles.errorDot} testID="settings-row-error-dot" />
)}
<Text style={textStyle} numberOfLines={1}>
{hint}
</Text>
</View>
);
}
function HintPlaceholder() {
const pulse = useSkeletonPulse();
return <SkeletonPulse pulse={pulse} style={styles.hintPlaceholder} />;
}
const styles = StyleSheet.create((theme) => ({
leading: {
marginRight: theme.spacing[3],
alignItems: "center",
justifyContent: "center",
},
control: {
marginRight: theme.spacing[3],
},
// The button under the row's content; it fills the row, padding included.
pressTarget: {
...StyleSheet.absoluteFill,
},
passThrough: {
pointerEvents: "none",
},
trailing: {
flexDirection: "row",
alignItems: "center",
flexShrink: 1,
},
hintLine: {
flexDirection: "row",
alignItems: "center",
gap: theme.spacing[1.5],
marginTop: theme.spacing[1],
},
// The line carries the hint's top margin, so the mark and the words share one baseline box.
hintText: {
marginTop: 0,
flexShrink: 1,
},
hintError: {
color: theme.colors.statusDanger,
},
errorDot: {
width: 8,
height: 8,
borderRadius: theme.borderRadius.full,
backgroundColor: theme.colors.statusDanger,
},
hintPlaceholder: {
position: "absolute",
left: 0,
top: theme.spacing[0.5],
bottom: theme.spacing[0.5],
width: theme.spacing[32],
borderRadius: theme.borderRadius.sm,
backgroundColor: theme.colors.surface2,
},
labelRow: { flexDirection: "row", alignItems: "center", gap: theme.spacing[2] },
summary: {
flexShrink: 1,
@@ -25,7 +25,7 @@ export interface SegmentedControlOption<T extends string> {
interface SegmentedControlProps<T extends string> {
options: SegmentedControlOption<T>[];
value: T;
value: T | null;
onValueChange: (value: T) => void;
size?: ControlSize;
hideLabels?: boolean;
@@ -112,7 +112,7 @@ function SegmentItem<T extends string>({
hideLabels: boolean;
segmentSizeStyle: StyleProp<ViewStyle>;
labelSizeStyle: StyleProp<TextStyle>;
currentValue: T;
currentValue: T | null;
onValueChange: (value: T) => void;
}) {
const labelStyle = useMemo(
@@ -16,7 +16,7 @@ import { formatThinkingOptionLabel } from "@/agent-controls/labels";
import { CombinedModelSelector } from "@/components/combined-model-selector";
import {
buildProviderSelectorProviders,
buildSelectableProviderSelectorProviders,
buildSelectorProvider,
type ProviderSelectorProvider,
} from "@/provider-selection/provider-selection";
import { filterSelectableModels } from "@/provider-selection/model-catalog";
@@ -1049,7 +1049,7 @@ export const AgentControls = memo(function AgentControls({
);
const agentModelSelectorProviders = useMemo(() => {
if (snapshotSelectedEntry) {
return buildSelectableProviderSelectorProviders([snapshotSelectedEntry]);
return [buildSelectorProvider(snapshotSelectedEntry)];
}
return buildProviderSelectorProviders({
providerDefinitions: agentProviderDefinitions,
@@ -9,6 +9,11 @@ export function getAcpProviderCatalog(): AcpProviderCatalogItem[] {
return ACP_PROVIDER_CATALOG;
}
/** The catalog's install guide for a provider added from it, or null for any other provider. */
export function readAcpProviderInstallGuide(provider: string): string | null {
return ACP_PROVIDER_CATALOG.find((entry) => entry.id === provider)?.installLink ?? null;
}
export function buildAcpProviderConfigPatch(
entry: AcpProviderCatalogItem,
hostSupports: (feature: HostFeatureName) => boolean = () => false,
@@ -236,8 +236,12 @@ export function useAgentFormState(options: UseAgentFormStateOptions): UseAgentFo
[snapshotEntries],
);
const snapshotModelSelectorProviders = useMemo(
() => buildSelectableProviderSelectorProviders(snapshotEntries, isConnected),
[snapshotEntries, isConnected],
() =>
buildSelectableProviderSelectorProviders(snapshotEntries, {
isConnected,
selectedProvider: formState.provider || null,
}),
[snapshotEntries, isConnected, formState.provider],
);
const snapshotSelectedEntry = useMemo(
() =>
+2 -6
View File
@@ -23,19 +23,16 @@ import {
DEFAULT_UI_BASE_FONT_SIZE,
MAX_CODE_FONT_SIZE,
MAX_CONTENT_FONT_SIZE,
MAX_CONTENT_MAX_WIDTH,
MAX_TERMINAL_SCROLLBACK_LINES,
MAX_UI_BASE_FONT_SIZE,
MIN_CODE_FONT_SIZE,
MIN_CONTENT_FONT_SIZE,
MIN_CONTENT_MAX_WIDTH,
MIN_TERMINAL_SCROLLBACK_LINES,
MIN_UI_BASE_FONT_SIZE,
loadAppSettingsFromStorage as loadAppSettingsFromStoragePure,
loadSettingsFromStorage as loadSettingsFromStoragePure,
normalizeAppSettings,
parseClampedFontSize,
parseContentMaxWidth,
parseTerminalScrollbackLines,
resolveContentMaxWidth,
sanitizeFontFamily,
@@ -43,6 +40,7 @@ import {
type AppSettings,
type AppSettingsUpdate,
type ChatDisplay,
type ContentWidthPreset,
type OpenInSidePanePreferences,
type PullRequestOpenLocation,
type DesktopSettingsBridge,
@@ -69,16 +67,13 @@ export {
DEFAULT_UI_BASE_FONT_SIZE,
MAX_CODE_FONT_SIZE,
MAX_CONTENT_FONT_SIZE,
MAX_CONTENT_MAX_WIDTH,
MAX_TERMINAL_SCROLLBACK_LINES,
MAX_UI_BASE_FONT_SIZE,
MIN_CODE_FONT_SIZE,
MIN_CONTENT_FONT_SIZE,
MIN_CONTENT_MAX_WIDTH,
MIN_TERMINAL_SCROLLBACK_LINES,
MIN_UI_BASE_FONT_SIZE,
parseClampedFontSize,
parseContentMaxWidth,
parseTerminalScrollbackLines,
resolveContentMaxWidth,
sanitizeFontFamily,
@@ -87,6 +82,7 @@ export type {
AppSettings,
AppSettingsUpdate,
ChatDisplay,
ContentWidthPreset,
AppLanguage,
OpenInSidePanePreferences,
PullRequestOpenLocation,
@@ -1121,49 +1121,64 @@ describe("parseClampedFontSize", () => {
});
});
describe("content max width", () => {
it("follows the current default until the user picks a width", async () => {
describe("content width", () => {
it("uses the default width when no preference is saved", async () => {
const deps = makeDeps();
const queryClient = new QueryClient();
await saveAppSettings({ queryClient, updates: { codeFontSize: 14 }, deps });
const stored = JSON.parse(deps.storage.entries.get(APP_SETTINGS_KEY) ?? "null");
expect(stored.contentMaxWidth).toBeNull();
expect(resolveContentMaxWidth(await loadAppSettingsFromStorage(deps))).toBe(
DEFAULT_CONTENT_MAX_WIDTH,
);
const settings = await loadAppSettingsFromStorage(deps);
expect(settings.contentWidth).toBe("default");
expect(resolveContentMaxWidth(settings)).toBe(DEFAULT_CONTENT_MAX_WIDTH);
});
it("keeps a picked width and returns to the default when reset", async () => {
it.each([
["wide", 1200],
["full", undefined],
["default", DEFAULT_CONTENT_MAX_WIDTH],
] as const)("persists the %s preset and resolves its width", async (contentWidth, expected) => {
const deps = makeDeps();
const queryClient = new QueryClient();
await saveAppSettings({ queryClient, updates: { contentWidth }, deps });
await saveAppSettings({ queryClient, updates: { contentMaxWidth: 1600 }, deps });
expect(resolveContentMaxWidth(await loadAppSettingsFromStorage(deps))).toBe(1600);
await saveAppSettings({ queryClient, updates: { contentMaxWidth: null }, deps });
expect(JSON.parse(deps.storage.entries.get(APP_SETTINGS_KEY) ?? "null").contentMaxWidth).toBe(
null,
);
expect(resolveContentMaxWidth(await loadAppSettingsFromStorage(deps))).toBe(
DEFAULT_CONTENT_MAX_WIDTH,
);
const settings = await loadAppSettingsFromStorage(deps);
expect(settings.contentWidth).toBe(contentWidth);
expect(resolveContentMaxWidth(settings)).toBe(expected);
});
it("clamps stored widths and drops malformed ones to the default", async () => {
const load = (contentMaxWidth: unknown) =>
loadAppSettingsFromStorage(
makeDeps({
storage: createInMemoryKeyValueStorage({
[APP_SETTINGS_KEY]: JSON.stringify({ contentMaxWidth }),
}),
}),
);
it("preserves a legacy custom width until a preset is picked", async () => {
const deps = makeDeps({
storage: createInMemoryKeyValueStorage({
[APP_SETTINGS_KEY]: JSON.stringify({ contentMaxWidth: 1600 }),
}),
});
const queryClient = new QueryClient();
const settings = await loadAppSettingsFromStorage(deps);
expect(settings.contentWidth).toBe(1600);
expect(resolveContentMaxWidth(settings)).toBe(1600);
expect((await load(100_000)).contentMaxWidth).toBe(4000);
expect((await load(10)).contentMaxWidth).toBe(600);
expect((await load("wide")).contentMaxWidth).toBeNull();
await saveAppSettings({ queryClient, updates: { codeFontSize: 14 }, deps });
expect((await loadAppSettingsFromStorage(deps)).contentWidth).toBe(1600);
await saveAppSettings({ queryClient, updates: { contentWidth: "default" }, deps });
expect((await loadAppSettingsFromStorage(deps)).contentWidth).toBe("default");
});
it.each([
[100_000, 4000],
[10, 600],
[null, "default"],
["wide", "default"],
])("normalizes legacy width %s on load", async (contentMaxWidth, expected) => {
const settings = await loadAppSettingsFromStorage(
makeDeps({
storage: createInMemoryKeyValueStorage({
[APP_SETTINGS_KEY]: JSON.stringify({ contentMaxWidth }),
}),
}),
);
expect(settings.contentWidth).toBe(expected);
});
});
+30 -16
View File
@@ -73,8 +73,11 @@ export const MIN_CODE_FONT_SIZE = 9;
export const MAX_CODE_FONT_SIZE = 22; // line-height 1.5×22=33 stays safe
export const MAX_FONT_FAMILY_LENGTH = 200;
export { DEFAULT_CONTENT_MAX_WIDTH };
export const MIN_CONTENT_MAX_WIDTH = 600;
export const MAX_CONTENT_MAX_WIDTH = 4000;
const WIDE_CONTENT_MAX_WIDTH = 1200;
const legacyContentMaxWidthSchema = clampedNumber(600, 4000);
const contentWidthPresetSchema = z.enum(["default", "wide", "full"]);
export type ContentWidthPreset = z.infer<typeof contentWidthPresetSchema>;
type ContentWidth = ContentWidthPreset | number;
export interface AppSettings {
theme: ThemePreference;
@@ -89,8 +92,8 @@ export interface AppSettings {
uiBaseFontSize: number; // clamped px, platform default 14 or 15
contentFontSize: number; // clamped px, platform default 15 or 16
codeFontSize: number; // clamped px, default 12
/** Max width of chat and markdown content in px; null follows the current default. */
contentMaxWidth: number | null;
/** Numbers preserve widths saved before presets were introduced. */
contentWidth: ContentWidth;
syntaxTheme: SyntaxThemeId; // default "one"
workspaceTitleSource: WorkspaceTitleSource;
sidebarWorkspaceTrailing: SidebarWorkspaceTrailing;
@@ -152,7 +155,7 @@ export const DEFAULT_CLIENT_SETTINGS: AppSettings = {
uiBaseFontSize: DEFAULT_UI_BASE_FONT_SIZE,
contentFontSize: DEFAULT_CONTENT_FONT_SIZE,
codeFontSize: DEFAULT_CODE_FONT_SIZE,
contentMaxWidth: null,
contentWidth: "default",
syntaxTheme: "one",
workspaceTitleSource: "title",
sidebarWorkspaceTrailing: "timestamp",
@@ -244,10 +247,12 @@ const StoredAppSettingsSchema = z
codeFontSize: clampedNumber(MIN_CODE_FONT_SIZE, MAX_CODE_FONT_SIZE).catch(
DEFAULT_CODE_FONT_SIZE,
),
contentMaxWidth: z
.null()
.or(clampedNumber(MIN_CONTENT_MAX_WIDTH, MAX_CONTENT_MAX_WIDTH))
.catch(null),
contentWidth: contentWidthPresetSchema
.or(legacyContentMaxWidthSchema)
.optional()
.catch(undefined),
// COMPAT(contentMaxWidth): preserve the previous numeric preference.
contentMaxWidth: legacyContentMaxWidthSchema.nullish().catch(undefined),
syntaxTheme: z.string().refine(isSyntaxThemeId).catch("one"),
workspaceTitleSource: z.enum(["title", "branch"]).catch("title"),
sidebarWorkspaceTrailing: z.enum(["diff", "timestamp", "none"]).catch("timestamp"),
@@ -303,9 +308,10 @@ const StoredAppSettingsSchema = z
manageBuiltInDaemon: z.boolean().optional().catch(undefined),
releaseChannel: z.enum(["stable", "beta"]).optional().catch(undefined),
})
.transform((stored) => {
.transform(({ contentMaxWidth, ...stored }) => {
const { legacyPullRequestsInSidePane, ...openInSidePane } = stored.openInSidePane;
const needsWrite =
contentMaxWidth !== undefined ||
(stored.uiBaseFontSize === undefined && stored.uiFontSize !== undefined) ||
stored.contentFontSize === undefined;
const uiBaseFontSize =
@@ -324,6 +330,7 @@ const StoredAppSettingsSchema = z
const chatDisplay = stored.chatDisplay ?? (groupsToolCalls ? "collapseToolCalls" : "full");
return {
...stored,
contentWidth: stored.contentWidth ?? contentMaxWidth ?? "default",
openInSidePane,
pullRequestOpenLocation:
stored.pullRequestOpenLocation ?? (legacyPullRequestsInSidePane ? "side" : "explorer"),
@@ -497,12 +504,19 @@ export function parseTerminalScrollbackLines(value: unknown): number | null {
);
}
export function parseContentMaxWidth(value: unknown): number | null {
return parseClampedFontSize(value, { min: MIN_CONTENT_MAX_WIDTH, max: MAX_CONTENT_MAX_WIDTH });
}
export function resolveContentMaxWidth(settings: Pick<AppSettings, "contentMaxWidth">): number {
return settings.contentMaxWidth ?? DEFAULT_CONTENT_MAX_WIDTH;
export function resolveContentMaxWidth({
contentWidth,
}: Pick<AppSettings, "contentWidth">): number | undefined {
switch (contentWidth) {
case "default":
return DEFAULT_CONTENT_MAX_WIDTH;
case "wide":
return WIDE_CONTENT_MAX_WIDTH;
case "full":
return undefined;
default:
return contentWidth;
}
}
export function parseClampedFontSize(
+43 -5
View File
@@ -1746,7 +1746,7 @@ export const ar: TranslationResources = {
},
providers: {
label: "المزوّدون",
title: "وكلاؤك",
title: "مزوّدوك",
description: "يشغّل Paseo أدوات CLI للوكلاء المثبتة على هذا الكمبيوتر",
},
projects: {
@@ -2711,10 +2711,11 @@ export const ar: TranslationResources = {
layout: {
title: "التخطيط",
contentWidth: "عرض المحتوى",
contentWidthHint: "أقصى عرض للمحادثة وملفات Markdown على الشاشات العريضة",
contentWidthAccessibility: "عرض المحتوى بالبكسل",
reset: "إعادة تعيين",
resetAccessibility: "إعادة عرض المحتوى إلى الافتراضي",
contentWidthHint: "عرض المحادثة ومحرر الرسائل ومعاينات Markdown",
contentWidthDefault: "افتراضي",
contentWidthWide: "عريض",
contentWidthFull: "كامل",
contentWidthCustom: "عرض مخصص · {{width}} بكسل",
},
syntax: {
title: "بناء الجملة",
@@ -3097,6 +3098,22 @@ export const ar: TranslationResources = {
providers: {
title: "مقدمي الخدمات",
addProvider: "إضافة مزود",
list: {
add: "مزود",
updatingTo: "جارٍ التحديث إلى {{version}}...",
},
detail: {
backToProviders: "العودة إلى المزودين",
notOnHost: "هذا المزود غير موجود على هذا المضيف",
enabled: "مفعّل",
unavailableTitle: "{{name}} غير متاح",
troubleshooting: "استكشاف الأخطاء",
status: "حالة المزود",
checked: "تم الفحص {{time}}",
diagnosticReport: "تقرير التشخيص",
dangerZone: "منطقة الخطر",
removeHint: "يحذف هذا المزود من config.json",
},
providerDetails: "تفاصيل مزود{{name}}",
enableProvider: "تمكين{{name}}",
unavailable: "اتصل بهذا المضيف لرؤية مقدمي الخدمة",
@@ -3138,10 +3155,31 @@ export const ar: TranslationResources = {
retrying: "جارٍ إعادة المحاولة...",
noSearchMatches: "لا توجد نماذج تطابق بحثك",
noneDetected: "لم يتم اكتشاف أي نماذج",
noCustom: "لا توجد نماذج مخصصة",
discovered: "اكتشف",
custom: "نماذج مخصصة",
updated: "تم تحديث{{time}}",
},
installation: {
title: "التثبيت",
version: "الإصدار",
installed: "مثبّت",
notInstalled: "غير مثبّت",
install: "تثبيت",
checking: "جارٍ التحقق...",
failed: "تعذّر التحقق من التثبيت",
updates: "التحديثات",
upToDate: "محدّث",
updateAvailable: "يتوفر تحديث",
updateInstructions: "تعليمات التحديث",
update: "تحديث",
updating: "جارٍ التحديث...",
updated: "تم التحديث",
updateFailed: "فشل التحديث",
outputTruncated: "تم حذف المخرجات السابقة.",
updatesFailed: "تعذّر التحقق من التحديثات",
installInstructions: "تعليمات التثبيت",
},
diagnostic: {
title: "التشخيص",
button: "التشخيص",
+43 -5
View File
@@ -1774,7 +1774,7 @@ export const en = {
},
providers: {
label: "Providers",
title: "Your agents",
title: "Your providers",
description: "Paseo runs the agent CLIs already on this computer",
},
projects: {
@@ -2806,10 +2806,11 @@ export const en = {
layout: {
title: "Layout",
contentWidth: "Content width",
contentWidthHint: "Max width of chat and Markdown files on wide screens",
contentWidthAccessibility: "Content width in pixels",
reset: "Reset",
resetAccessibility: "Reset content width to default",
contentWidthHint: "Width of chat, composer, and Markdown previews",
contentWidthDefault: "Default",
contentWidthWide: "Wide",
contentWidthFull: "Full",
contentWidthCustom: "Custom width · {{width}} px",
},
syntax: {
title: "Syntax",
@@ -3196,6 +3197,22 @@ export const en = {
providers: {
title: "Providers",
addProvider: "Add provider",
list: {
add: "Provider",
updatingTo: "Updating to {{version}}...",
},
detail: {
backToProviders: "Back to providers",
notOnHost: "This provider isn't on this host",
enabled: "Enabled",
unavailableTitle: "{{name}} isn't available",
troubleshooting: "Troubleshooting",
status: "Provider status",
checked: "Checked {{time}}",
diagnosticReport: "Diagnostic report",
dangerZone: "Danger zone",
removeHint: "Deletes this provider from config.json",
},
providerDetails: "{{name}} provider details",
enableProvider: "Enable {{name}}",
unavailable: "Connect to this host to see providers",
@@ -3237,10 +3254,31 @@ export const en = {
retrying: "Retrying...",
noSearchMatches: "No models match your search",
noneDetected: "No models detected",
noCustom: "No custom models",
discovered: "Discovered",
custom: "Custom models",
updated: "Updated {{time}}",
},
installation: {
title: "Installation",
version: "Version",
installed: "Installed",
notInstalled: "Not installed",
install: "Install",
checking: "Checking...",
failed: "Couldn't check this installation",
updates: "Updates",
upToDate: "Up to date",
updateAvailable: "Update available",
updateInstructions: "Update instructions",
update: "Update",
updating: "Updating...",
updated: "Updated",
updateFailed: "Update failed",
outputTruncated: "Earlier output was dropped.",
updatesFailed: "Couldn't check for updates",
installInstructions: "Install instructions",
},
diagnostic: {
title: "Diagnostic",
button: "Diagnostic",
+43 -5
View File
@@ -1793,7 +1793,7 @@ export const es: TranslationResources = {
},
providers: {
label: "Proveedores",
title: "Tus agentes",
title: "Tus proveedores",
description: "Paseo usa las CLI de agentes que ya están en este ordenador",
},
projects: {
@@ -2734,10 +2734,11 @@ export const es: TranslationResources = {
layout: {
title: "Diseño",
contentWidth: "Ancho del contenido",
contentWidthHint: "Ancho máximo del chat y de los archivos Markdown en pantallas anchas",
contentWidthAccessibility: "Ancho del contenido en píxeles",
reset: "Restablecer",
resetAccessibility: "Restablecer el ancho del contenido",
contentWidthHint: "Ancho del chat, el campo de mensaje y las vistas previas de Markdown",
contentWidthDefault: "Predeterminado",
contentWidthWide: "Ancho",
contentWidthFull: "Completo",
contentWidthCustom: "Ancho personalizado · {{width}} px",
},
syntax: {
title: "Sintaxis",
@@ -3126,6 +3127,22 @@ export const es: TranslationResources = {
providers: {
title: "Proveedores",
addProvider: "Agregar proveedor",
list: {
add: "Proveedor",
updatingTo: "Actualizando a {{version}}...",
},
detail: {
backToProviders: "Volver a proveedores",
notOnHost: "Este proveedor no está en este host",
enabled: "Activado",
unavailableTitle: "{{name}} no está disponible",
troubleshooting: "Solución de problemas",
status: "Estado del proveedor",
checked: "Comprobado {{time}}",
diagnosticReport: "Informe de diagnóstico",
dangerZone: "Zona de peligro",
removeHint: "Elimina este proveedor de config.json",
},
providerDetails: "Detalles del proveedor{{name}}",
enableProvider: "Habilitar{{name}}",
unavailable: "Conéctese a este host para ver proveedores",
@@ -3167,10 +3184,31 @@ export const es: TranslationResources = {
retrying: "Reintentando...",
noSearchMatches: "Ningún modelo coincide con tu búsqueda",
noneDetected: "No se detectaron modelos",
noCustom: "No hay modelos personalizados",
discovered: "descubierto",
custom: "Modelos personalizados",
updated: "{{time}}actualizado",
},
installation: {
title: "Instalación",
version: "Versión",
installed: "Instalado",
notInstalled: "No instalado",
install: "Instalar",
checking: "Comprobando...",
failed: "No se pudo comprobar la instalación",
updates: "Actualizaciones",
upToDate: "Actualizado",
updateAvailable: "Actualización disponible",
updateInstructions: "Instrucciones de actualización",
update: "Actualizar",
updating: "Actualizando...",
updated: "Actualizado",
updateFailed: "No se pudo actualizar",
outputTruncated: "Se descartó la salida anterior.",
updatesFailed: "No se pudo comprobar si hay actualizaciones",
installInstructions: "Instrucciones de instalación",
},
diagnostic: {
title: "Diagnóstico",
button: "Diagnóstico",
+43 -6
View File
@@ -1791,7 +1791,7 @@ export const fr: TranslationResources = {
},
providers: {
label: "Fournisseurs",
title: "Vos agents",
title: "Vos fournisseurs",
description: "Paseo utilise les CLI d'agents déjà installées sur cet ordinateur",
},
projects: {
@@ -2735,11 +2735,11 @@ export const fr: TranslationResources = {
layout: {
title: "Mise en page",
contentWidth: "Largeur du contenu",
contentWidthHint:
"Largeur maximale de la discussion et des fichiers Markdown sur les grands écrans",
contentWidthAccessibility: "Largeur du contenu en pixels",
reset: "Réinitialiser",
resetAccessibility: "Réinitialiser la largeur du contenu",
contentWidthHint: "Largeur du chat, de la zone de saisie et des aperçus Markdown",
contentWidthDefault: "Par défaut",
contentWidthWide: "Large",
contentWidthFull: "Pleine largeur",
contentWidthCustom: "Largeur personnalisée · {{width}} px",
},
syntax: {
title: "Syntaxe",
@@ -3133,6 +3133,22 @@ export const fr: TranslationResources = {
providers: {
title: "Fournisseurs",
addProvider: "Ajouter un fournisseur",
list: {
add: "Fournisseur",
updatingTo: "Mise à jour vers {{version}}…",
},
detail: {
backToProviders: "Retour aux fournisseurs",
notOnHost: "Ce fournisseur n'est pas sur cet hôte",
enabled: "Activé",
unavailableTitle: "{{name}} n'est pas disponible",
troubleshooting: "Dépannage",
status: "État du fournisseur",
checked: "Vérifié {{time}}",
diagnosticReport: "Rapport de diagnostic",
dangerZone: "Zone de danger",
removeHint: "Supprime ce fournisseur de config.json",
},
providerDetails: "Détails du fournisseur {{name}}",
enableProvider: "Activer {{name}}",
unavailable: "Connectez-vous à cet hôte pour voir les fournisseurs",
@@ -3175,10 +3191,31 @@ export const fr: TranslationResources = {
retrying: "Nouvelle tentative…",
noSearchMatches: "Aucun modèle ne correspond à votre recherche",
noneDetected: "Aucun modèle détecté",
noCustom: "Aucun modèle personnalisé",
discovered: "Détectés",
custom: "Modèles personnalisés",
updated: "Mis à jour {{time}}",
},
installation: {
title: "Installation",
version: "Version",
installed: "Installé",
notInstalled: "Non installé",
install: "Installer",
checking: "Vérification...",
failed: "Impossible de vérifier l'installation",
updates: "Mises à jour",
upToDate: "À jour",
updateAvailable: "Mise à jour disponible",
updateInstructions: "Instructions de mise à jour",
update: "Mettre à jour",
updating: "Mise à jour...",
updated: "Mis à jour",
updateFailed: "Échec de la mise à jour",
outputTruncated: "La sortie précédente a été supprimée.",
updatesFailed: "Impossible de vérifier les mises à jour",
installInstructions: "Instructions d'installation",
},
diagnostic: {
title: "Diagnostic",
button: "Diagnostic",
+43 -5
View File
@@ -1764,7 +1764,7 @@ export const ja: TranslationResources = {
},
providers: {
label: "プロバイダー",
title: "エージェント",
title: "プロバイダー",
description: "Paseo はこのコンピューターにインストール済みのエージェント CLI を使います",
},
projects: {
@@ -2700,10 +2700,11 @@ export const ja: TranslationResources = {
layout: {
title: "レイアウト",
contentWidth: "コンテンツ幅",
contentWidthHint: "ワイド画面でのチャットと Markdown ファイルの最大幅",
contentWidthAccessibility: "コンテンツ幅 (ピクセル)",
reset: "リセット",
resetAccessibility: "コンテンツ幅をデフォルトに戻す",
contentWidthHint: "チャット、入力欄、Markdown プレビューの幅",
contentWidthDefault: "標準",
contentWidthWide: "ワイド",
contentWidthFull: "全幅",
contentWidthCustom: "カスタム幅 · {{width}} px",
},
syntax: {
title: "構文ハイライト",
@@ -3094,6 +3095,22 @@ export const ja: TranslationResources = {
providers: {
title: "プロバイダー",
addProvider: "プロバイダーを追加",
list: {
add: "プロバイダー",
updatingTo: "{{version}} に更新中...",
},
detail: {
backToProviders: "プロバイダーに戻る",
notOnHost: "このホストにはこのプロバイダーがありません",
enabled: "有効",
unavailableTitle: "{{name}} は利用できません",
troubleshooting: "トラブルシューティング",
status: "プロバイダーの状態",
checked: "{{time}}に確認",
diagnosticReport: "診断レポート",
dangerZone: "危険な操作",
removeHint: "このプロバイダーを config.json から削除します",
},
providerDetails: "{{name}}プロバイダーの詳細",
enableProvider: "{{name}}を有効にする",
unavailable: "プロバイダーを見るにはこのホストに接続してください",
@@ -3135,10 +3152,31 @@ export const ja: TranslationResources = {
retrying: "再試行中...",
noSearchMatches: "検索に一致するモデルがありません",
noneDetected: "モデルが検出されませんでした",
noCustom: "カスタムモデルはありません",
discovered: "検出済み",
custom: "カスタムモデル",
updated: "{{time}}に更新",
},
installation: {
title: "インストール",
version: "バージョン",
installed: "インストール済み",
notInstalled: "未インストール",
install: "インストール",
checking: "確認中...",
failed: "インストールを確認できませんでした",
updates: "アップデート",
upToDate: "最新です",
updateAvailable: "アップデートがあります",
updateInstructions: "アップデート手順",
update: "アップデート",
updating: "アップデート中...",
updated: "アップデート済み",
updateFailed: "アップデートに失敗しました",
outputTruncated: "以前の出力は破棄されました。",
updatesFailed: "アップデートを確認できませんでした",
installInstructions: "インストール手順",
},
diagnostic: {
title: "診断",
button: "診断",
+43 -5
View File
@@ -1757,7 +1757,7 @@ export const ko: TranslationResources = {
},
providers: {
label: "제공자",
title: "에이전트",
title: "제공자",
description: "Paseo는 이 컴퓨터에 이미 설치된 에이전트 CLI를 사용합니다",
},
projects: {
@@ -2690,10 +2690,11 @@ export const ko: TranslationResources = {
layout: {
title: "레이아웃",
contentWidth: "콘텐츠 너비",
contentWidthHint: "와이드 화면에서 채팅과 Markdown 파일의 최대 너비",
contentWidthAccessibility: "콘텐츠 너비(픽셀)",
reset: "재설정",
resetAccessibility: "콘텐츠 너비를 기본값으로 재설정",
contentWidthHint: "채팅, 메시지 입력란, Markdown 미리보기의 너비",
contentWidthDefault: "기본",
contentWidthWide: "넓게",
contentWidthFull: "전체",
contentWidthCustom: "사용자 지정 너비 · {{width}} px",
},
syntax: {
title: "구문",
@@ -3079,6 +3080,22 @@ export const ko: TranslationResources = {
providers: {
title: "프로바이더",
addProvider: "프로바이더 추가",
list: {
add: "프로바이더",
updatingTo: "{{version}}(으)로 업데이트 중...",
},
detail: {
backToProviders: "프로바이더로 돌아가기",
notOnHost: "이 호스트에 없는 프로바이더입니다",
enabled: "사용",
unavailableTitle: "{{name}}을(를) 사용할 수 없습니다",
troubleshooting: "문제 해결",
status: "프로바이더 상태",
checked: "{{time}} 확인됨",
diagnosticReport: "진단 보고서",
dangerZone: "위험 구역",
removeHint: "config.json에서 이 프로바이더를 삭제합니다",
},
providerDetails: "{{name}} 프로바이더 세부 정보",
enableProvider: "{{name}} 활성화",
unavailable: "프로바이더를 보려면 이 호스트에 연결하세요",
@@ -3121,10 +3138,31 @@ export const ko: TranslationResources = {
retrying: "다시 시도 중...",
noSearchMatches: "검색과 일치하는 모델이 없습니다",
noneDetected: "감지된 모델이 없습니다",
noCustom: "사용자 지정 모델 없음",
discovered: "발견됨",
custom: "사용자 지정 모델",
updated: "{{time}} 업데이트됨",
},
installation: {
title: "설치",
version: "버전",
installed: "설치됨",
notInstalled: "설치되지 않음",
install: "설치",
checking: "확인 중...",
failed: "설치를 확인할 수 없습니다",
updates: "업데이트",
upToDate: "최신 상태",
updateAvailable: "업데이트 가능",
updateInstructions: "업데이트 안내",
update: "업데이트",
updating: "업데이트 중...",
updated: "업데이트됨",
updateFailed: "업데이트 실패",
outputTruncated: "이전 출력이 삭제되었습니다.",
updatesFailed: "업데이트를 확인할 수 없습니다",
installInstructions: "설치 안내",
},
diagnostic: {
title: "진단",
button: "진단",
+43 -5
View File
@@ -1778,7 +1778,7 @@ export const ptBR: TranslationResources = {
},
providers: {
label: "Provedores",
title: "Seus agentes",
title: "Seus provedores",
description: "O Paseo usa as CLIs de agentes já instaladas neste computador",
},
projects: {
@@ -2714,10 +2714,11 @@ export const ptBR: TranslationResources = {
layout: {
title: "Layout",
contentWidth: "Largura do conteúdo",
contentWidthHint: "Largura máxima do chat e dos arquivos Markdown em telas largas",
contentWidthAccessibility: "Largura do conteúdo em pixels",
reset: "Redefinir",
resetAccessibility: "Redefinir a largura do conteúdo",
contentWidthHint: "Largura do chat, do campo de mensagem e das prévias de Markdown",
contentWidthDefault: "Padrão",
contentWidthWide: "Largo",
contentWidthFull: "Total",
contentWidthCustom: "Largura personalizada · {{width}} px",
},
syntax: {
title: "Sintaxe",
@@ -3107,6 +3108,22 @@ export const ptBR: TranslationResources = {
providers: {
title: "Provedores",
addProvider: "Adicionar provedor",
list: {
add: "Provedor",
updatingTo: "Atualizando para {{version}}...",
},
detail: {
backToProviders: "Voltar para provedores",
notOnHost: "Este provedor não está neste host",
enabled: "Ativado",
unavailableTitle: "{{name}} não está disponível",
troubleshooting: "Solução de problemas",
status: "Status do provedor",
checked: "Verificado {{time}}",
diagnosticReport: "Relatório de diagnóstico",
dangerZone: "Zona de perigo",
removeHint: "Exclui este provedor do config.json",
},
providerDetails: "Detalhes do provedor {{name}}",
enableProvider: "Ativar {{name}}",
unavailable: "Conecte-se a este host para ver provedores",
@@ -3148,10 +3165,31 @@ export const ptBR: TranslationResources = {
retrying: "Tentando novamente...",
noSearchMatches: "Nenhum modelo corresponde à sua busca",
noneDetected: "Nenhum modelo detectado",
noCustom: "Nenhum modelo personalizado",
discovered: "Descobertos",
custom: "Modelos personalizados",
updated: "Atualizado {{time}}",
},
installation: {
title: "Instalação",
version: "Versão",
installed: "Instalado",
notInstalled: "Não instalado",
install: "Instalar",
checking: "Verificando...",
failed: "Não foi possível verificar a instalação",
updates: "Atualizações",
upToDate: "Atualizado",
updateAvailable: "Atualização disponível",
updateInstructions: "Instruções de atualização",
update: "Atualizar",
updating: "Atualizando...",
updated: "Atualizado",
updateFailed: "Falha na atualização",
outputTruncated: "A saída anterior foi descartada.",
updatesFailed: "Não foi possível verificar atualizações",
installInstructions: "Instruções de instalação",
},
diagnostic: {
title: "Diagnóstico",
button: "Diagnóstico",
+43 -5
View File
@@ -1777,7 +1777,7 @@ export const ru: TranslationResources = {
},
providers: {
label: "Провайдеры",
title: "Ваши агенты",
title: "Ваши провайдеры",
description: "Paseo использует CLI агентов, уже установленные на этом компьютере",
},
projects: {
@@ -2722,10 +2722,11 @@ export const ru: TranslationResources = {
layout: {
title: "Макет",
contentWidth: "Ширина содержимого",
contentWidthHint: "Максимальная ширина чата и файлов Markdown на широких экранах",
contentWidthAccessibility: "Ширина содержимого в пикселях",
reset: "Сбросить",
resetAccessibility: "Сбросить ширину содержимого",
contentWidthHint: "Ширина чата, поля ввода и предпросмотра Markdown",
contentWidthDefault: "По умолчанию",
contentWidthWide: "Широкий",
contentWidthFull: "На всю ширину",
contentWidthCustom: "Своя ширина · {{width}} пкс",
},
syntax: {
title: "Синтаксис",
@@ -3118,6 +3119,22 @@ export const ru: TranslationResources = {
providers: {
title: "Провайдеры",
addProvider: "Добавить провайдера",
list: {
add: "Провайдер",
updatingTo: "Обновление до {{version}}...",
},
detail: {
backToProviders: "Назад к провайдерам",
notOnHost: "Этого провайдера нет на этом хосте",
enabled: "Включён",
unavailableTitle: "{{name}} недоступен",
troubleshooting: "Диагностика",
status: "Состояние провайдера",
checked: "Проверено {{time}}",
diagnosticReport: "Диагностический отчёт",
dangerZone: "Опасная зона",
removeHint: "Удаляет этого провайдера из config.json",
},
providerDetails: "Сведения о провайдере {{name}}",
enableProvider: "Включить {{name}}",
unavailable: "Подключитесь к этому хосту, чтобы увидеть провайдеров",
@@ -3160,10 +3177,31 @@ export const ru: TranslationResources = {
retrying: "Повторная попытка...",
noSearchMatches: "Ни одна модель не соответствует вашему запросу",
noneDetected: "Модели не обнаружены",
noCustom: "Нет пользовательских моделей",
discovered: "Обнаруженные модели",
custom: "Пользовательские модели",
updated: "Обновлено {{time}}",
},
installation: {
title: "Установка",
version: "Версия",
installed: "Установлено",
notInstalled: "Не установлено",
install: "Установить",
checking: "Проверка...",
failed: "Не удалось проверить установку",
updates: "Обновления",
upToDate: "Актуальная версия",
updateAvailable: "Доступно обновление",
updateInstructions: "Инструкции по обновлению",
update: "Обновить",
updating: "Обновление...",
updated: "Обновлено",
updateFailed: "Не удалось обновить",
outputTruncated: "Более ранний вывод был отброшен.",
updatesFailed: "Не удалось проверить обновления",
installInstructions: "Инструкции по установке",
},
diagnostic: {
title: "Диагностика",
button: "Диагностика",
+43 -5
View File
@@ -1729,7 +1729,7 @@ export const zhCN: TranslationResources = {
},
providers: {
label: "提供方",
title: "你的代理",
title: "你的提供方",
description: "Paseo 使用这台电脑上已安装的代理 CLI",
},
projects: {
@@ -2646,10 +2646,11 @@ export const zhCN: TranslationResources = {
layout: {
title: "布局",
contentWidth: "内容宽度",
contentWidthHint: "宽屏上聊天和 Markdown 文件的最大宽度",
contentWidthAccessibility: "内容宽度(像素)",
reset: "重置",
resetAccessibility: "将内容宽度重置为默认值",
contentWidthHint: "聊天、消息输入框和 Markdown 预览的宽度",
contentWidthDefault: "默认",
contentWidthWide: "宽版",
contentWidthFull: "全宽",
contentWidthCustom: "自定义宽度 · {{width}} px",
},
syntax: {
title: "语法",
@@ -3026,6 +3027,22 @@ export const zhCN: TranslationResources = {
providers: {
title: "Providers",
addProvider: "添加 Provider",
list: {
add: "Provider",
updatingTo: "正在更新到 {{version}}...",
},
detail: {
backToProviders: "返回 Provider 列表",
notOnHost: "此 Host 上没有这个 Provider",
enabled: "已启用",
unavailableTitle: "{{name}} 不可用",
troubleshooting: "故障排查",
status: "Provider 状态",
checked: "{{time}}检查",
diagnosticReport: "诊断报告",
dangerZone: "危险操作",
removeHint: "从 config.json 中删除此 Provider",
},
providerDetails: "{{name}} Provider 详情",
enableProvider: "启用 {{name}}",
unavailable: "连接到这个 Host 以查看 Providers",
@@ -3067,10 +3084,31 @@ export const zhCN: TranslationResources = {
retrying: "正在重试...",
noSearchMatches: "没有匹配搜索的 Model",
noneDetected: "未检测到 Model",
noCustom: "没有自定义模型",
discovered: "已发现",
custom: "自定义 Models",
updated: "已更新 {{time}}",
},
installation: {
title: "安装",
version: "版本",
installed: "已安装",
notInstalled: "未安装",
install: "安装",
checking: "正在检查...",
failed: "无法检查安装状态",
updates: "更新",
upToDate: "已是最新",
updateAvailable: "有可用更新",
updateInstructions: "更新说明",
update: "更新",
updating: "正在更新...",
updated: "已更新",
updateFailed: "更新失败",
outputTruncated: "较早的输出已被丢弃。",
updatesFailed: "无法检查更新",
installInstructions: "安装说明",
},
diagnostic: {
title: "诊断",
button: "诊断",
@@ -7,6 +7,7 @@ import {
buildOpenProjectRoute,
buildProjectSettingsRoute,
buildProjectsSettingsRoute,
buildProviderSettingsRoute,
buildSettingsHostSectionRoute,
buildSettingsRoute,
type HostSectionSlug,
@@ -40,7 +41,8 @@ export type SettingsView =
| { kind: "root" }
| { kind: "section"; section: SettingsSectionSlug }
| { kind: "host"; serverId: string; section: HostSectionSlug }
| { kind: "project"; serverId: string; projectId: string };
| { kind: "project"; serverId: string; projectId: string }
| { kind: "provider"; serverId: string; providerId: string };
export function openHostOverview(serverId: string): void {
router.push(buildSettingsHostSectionRoute(serverId, "host"));
@@ -50,6 +52,10 @@ export function openProjectSettings(serverId: string, projectId: string): void {
router.push(buildProjectSettingsRoute(serverId, projectId));
}
export function openProviderSettings(serverId: string, providerId: string): void {
router.push(buildProviderSettingsRoute(serverId, providerId));
}
export function returnFromSettings(view: SettingsView): void {
if (view.kind === "root") {
const destination = getSettingsSidebarReturn();
@@ -74,5 +80,6 @@ export function returnFromSettings(view: SettingsView): void {
if (view.kind === "plugin" || view.kind === "pluginListing")
parent = buildSettingsHostSectionRoute(view.serverId, "plugins");
if (view.kind === "project") parent = buildProjectsSettingsRoute(view.serverId);
if (view.kind === "provider") parent = buildSettingsHostSectionRoute(view.serverId, "providers");
router.dismissTo(parent as Href);
}
@@ -3,11 +3,7 @@ import { useTranslation } from "react-i18next";
import { Text, View, type PressableStateCallbackType } from "react-native";
import { StyleSheet, withUnistyles } from "react-native-unistyles";
import { Check } from "lucide-react-native";
import {
AdaptiveModalSheet,
FULL_SHEET_SNAP_POINTS,
SheetFooter,
} from "@/components/adaptive-modal-sheet";
import { AdaptiveModalSheet, SheetFooter } from "@/components/adaptive-modal-sheet";
import { PaseoLogo } from "@/components/icons/paseo-logo";
import { Button } from "@/components/ui/button";
import { PressHighlight } from "@/components/ui/press-highlight";
@@ -17,6 +13,7 @@ import { useProjectSuggestions, type ProjectSuggestionsController } from "@/proj
import type { Theme } from "@/styles/theme";
import type { OnboardingModel, OnboardingState, OnboardingStepId } from "./model";
import { useOrchestrationSetup, type OrchestrationSetupController } from "./orchestration-setup";
import { SETUP_CARD_FRAME } from "./setup-card";
import { OnboardingStepContent } from "./steps";
type OpenState = Extract<OnboardingState, { status: "open" }>;
@@ -112,9 +109,9 @@ export function OnboardingModal({ model, state }: { model: OnboardingModel; stat
header={isCompact ? compactHeader : undefined}
footer={isCompact ? actions : undefined}
scrollable={false}
snapPoints={FULL_SHEET_SNAP_POINTS}
desktopMaxWidth={880}
desktopHeight={640}
snapPoints={SETUP_CARD_FRAME.snapPoints}
desktopMaxWidth={SETUP_CARD_FRAME.desktopMaxWidth}
desktopHeight={SETUP_CARD_FRAME.desktopHeight}
contentStyle={styles.content}
testID="onboarding-modal"
>
@@ -0,0 +1,8 @@
import { FULL_SHEET_SNAP_POINTS } from "@/components/adaptive-modal-sheet";
/** The setup card's frame. A sheet opened from a setup step takes the same one to cover the card. */
export const SETUP_CARD_FRAME = {
snapPoints: FULL_SHEET_SNAP_POINTS,
desktopMaxWidth: 880,
desktopHeight: 640,
};
@@ -1,10 +1,44 @@
import { useCallback, useState } from "react";
import { View } from "react-native";
import { ProvidersSection } from "@/screens/settings/providers-section";
import { ProviderDetailSheet, ProviderList, type ProviderSheetFrame } from "@/provider-settings";
import { SETUP_CARD_FRAME } from "../setup-card";
/** Provider sheets cover the setup card and return to it, so they read as pages of setup. */
const SETUP_SHEET_FRAME: ProviderSheetFrame = { ...SETUP_CARD_FRAME, returns: true };
interface OpenedProvider {
provider: string;
visible: boolean;
}
export function ProvidersStep({ serverId }: { serverId: string }) {
// The provider outlives `visible` so the sheet can animate out.
const [opened, setOpened] = useState<OpenedProvider | null>(null);
const openProvider = useCallback(
(provider: string) => setOpened({ provider, visible: true }),
[],
);
const closeProvider = useCallback(
() => setOpened((current) => (current ? { ...current, visible: false } : null)),
[],
);
return (
<View>
<ProvidersSection serverId={serverId} />
<ProviderList
serverId={serverId}
onOpenProvider={openProvider}
sheetFrame={SETUP_SHEET_FRAME}
/>
{opened ? (
<ProviderDetailSheet
key={opened.provider}
serverId={serverId}
provider={opened.provider}
visible={opened.visible}
onClose={closeProvider}
frame={SETUP_SHEET_FRAME}
/>
) : null}
</View>
);
}
@@ -1,6 +1,5 @@
import { useQueryClient } from "@tanstack/react-query";
import { router } from "expo-router";
import { ArrowLeft } from "lucide-react-native";
import { useCallback, useMemo, useState, type ReactNode } from "react";
import { useTranslation } from "react-i18next";
import { Image, ScrollView, Text, View } from "react-native";
@@ -14,7 +13,12 @@ import type {
PluginListingDetail,
} from "@getpaseo/protocol/plugin-registry";
import { MarkdownRenderer } from "@/components/markdown/renderer";
import { SettingsCard, SettingsRow, SettingsSection } from "@/components/settings";
import {
SettingsBackLink,
SettingsCard,
SettingsRow,
SettingsSection,
} from "@/components/settings";
import { Alert } from "@/components/ui/alert";
import { Button } from "@/components/ui/button";
import { ExternalLink } from "@/components/ui/external-link";
@@ -428,9 +432,9 @@ export function PluginPage({
}, [listingId, onBack, serverId, subject.kind]);
const back = compact ? null : (
<Button onPress={onBack} variant="ghost" leftIcon={ArrowLeft} style={styles.back}>
{t("settings.plugins.screens.backToPlugins")}
</Button>
<View style={styles.back}>
<SettingsBackLink label={t("settings.plugins.screens.backToPlugins")} onPress={onBack} />
</View>
);
if (loading)
return (
@@ -542,7 +546,7 @@ function PluginPageBody({
}
const styles = StyleSheet.create((theme) => ({
back: { alignSelf: "flex-start", paddingHorizontal: 0, marginBottom: theme.spacing[4] },
back: { marginBottom: theme.spacing[4] },
header: {
flexDirection: "row",
alignItems: "center",
@@ -7,6 +7,7 @@ import {
buildProviderSelectorProviders,
buildSelectableProviderSelectorProviders,
buildSelectedTriggerLabel,
buildSelectorProvider,
filterAndRankModelRows,
matchesModelSearch,
resolveEffectiveComposerModeId,
@@ -21,7 +22,7 @@ describe("combined model selector data", () => {
snapshotEntry({ provider: "waiting", status: "loading", models: [] }),
snapshotEntry({ provider: "codex", status: "ready", models: [codexModel] }),
],
false,
{ isConnected: false, selectedProvider: null },
);
expect(providers[0].modelSelection).toEqual({
kind: "error",
@@ -54,13 +55,16 @@ describe("combined model selector data", () => {
it("builds selector providers from ready enabled snapshot entries", () => {
expect(
buildSelectableProviderSelectorProviders([
snapshotEntry({
provider: "codex",
label: "Codex",
models: [codexModel],
}),
]),
buildSelectableProviderSelectorProviders(
[
snapshotEntry({
provider: "codex",
label: "Codex",
models: [codexModel],
}),
],
{ selectedProvider: null },
),
).toEqual([
{
id: "codex",
@@ -91,9 +95,10 @@ describe("combined model selector data", () => {
isSelectable: false,
};
const [provider] = buildSelectableProviderSelectorProviders([
snapshotEntry({ provider: "codex", models: [codexModel, compatibilityModel] }),
]);
const [provider] = buildSelectableProviderSelectorProviders(
[snapshotEntry({ provider: "codex", models: [codexModel, compatibilityModel] })],
{ selectedProvider: null },
);
expect(provider?.modelSelection).toMatchObject({
kind: "models",
@@ -103,13 +108,16 @@ describe("combined model selector data", () => {
it("synthesizes a default model row for ready enabled providers without explicit models", () => {
expect(
buildSelectableProviderSelectorProviders([
snapshotEntry({
provider: "codewhale",
label: "CodeWhale",
models: [],
}),
]),
buildSelectableProviderSelectorProviders(
[
snapshotEntry({
provider: "codewhale",
label: "CodeWhale",
models: [],
}),
],
{ selectedProvider: null },
),
).toEqual([
{
id: "codewhale",
@@ -134,33 +142,34 @@ describe("combined model selector data", () => {
it("excludes disabled providers from selector data", () => {
expect(
buildSelectableProviderSelectorProviders([
snapshotEntry({
provider: "codewhale",
label: "CodeWhale",
enabled: false,
models: [],
}),
]),
buildSelectableProviderSelectorProviders(
[
snapshotEntry({
provider: "codewhale",
label: "CodeWhale",
enabled: false,
models: [],
}),
],
{ selectedProvider: null },
),
).toEqual([]);
});
it("surfaces non-ready providers with their state-specific selection", () => {
expect(
buildSelectableProviderSelectorProviders([
snapshotEntry({ provider: "loading-provider", status: "loading", models: [] }),
snapshotEntry({
provider: "error-provider",
status: "error",
error: "boom",
models: [],
}),
snapshotEntry({
provider: "unavailable-provider",
status: "unavailable",
models: [],
}),
]),
buildSelectableProviderSelectorProviders(
[
snapshotEntry({ provider: "loading-provider", status: "loading", models: [] }),
snapshotEntry({
provider: "error-provider",
status: "error",
error: "boom",
models: [],
}),
],
{ selectedProvider: null },
),
).toEqual([
{
id: "loading-provider",
@@ -172,14 +181,45 @@ describe("combined model selector data", () => {
label: "error-provider",
modelSelection: { kind: "error", message: "boom" },
},
{
id: "unavailable-provider",
label: "unavailable-provider",
modelSelection: { kind: "error", message: "Unavailable" },
},
]);
});
it("leaves out enabled providers that are not installed", () => {
expect(
buildSelectableProviderSelectorProviders(
[
snapshotEntry({ provider: "codex", label: "Codex" }),
snapshotEntry({ provider: "gemini", status: "unavailable", models: [] }),
],
{ selectedProvider: null },
).map((provider) => provider.id),
).toEqual(["codex"]);
});
it("keeps a saved choice whose provider is not installed, labelled Unavailable", () => {
const providers = buildSelectableProviderSelectorProviders(
[
snapshotEntry({ provider: "codex", label: "Codex" }),
snapshotEntry({ provider: "gemini", status: "unavailable", models: [] }),
],
{ selectedProvider: "gemini" },
);
expect(providers.map((provider) => provider.id)).toEqual(["codex", "gemini"]);
expect(providers[1].modelSelection).toEqual({ kind: "error", message: "Unavailable" });
});
it("keeps an agent's own provider in its selector when that provider is not installed", () => {
expect(
buildSelectorProvider(
snapshotEntry({ provider: "gemini", status: "unavailable", models: [] }),
),
).toEqual({
id: "gemini",
label: "gemini",
modelSelection: { kind: "error", message: "Unavailable" },
});
});
it("builds selector providers from an already-curated provider list", () => {
const providerDefinitions: AgentProviderDefinition[] = [
{
@@ -278,18 +318,21 @@ describe("combined model selector data", () => {
});
it("resolves selected labels from explicit provider model-selection state", () => {
const providers = buildSelectableProviderSelectorProviders([
snapshotEntry({
provider: "codex",
label: "Codex",
models: [codexModel],
}),
snapshotEntry({
provider: "codewhale",
label: "CodeWhale",
models: [],
}),
]);
const providers = buildSelectableProviderSelectorProviders(
[
snapshotEntry({
provider: "codex",
label: "Codex",
models: [codexModel],
}),
snapshotEntry({
provider: "codewhale",
label: "CodeWhale",
models: [],
}),
],
{ selectedProvider: null },
);
expect(
resolveSelectedModelLabel({
@@ -329,13 +372,16 @@ describe("combined model selector data", () => {
});
it("keeps a stored selected model visible when current snapshot rows no longer offer it", () => {
const providers = buildSelectableProviderSelectorProviders([
snapshotEntry({
provider: "codex",
label: "Codex",
models: [{ provider: "codex", id: "gpt-5.4", label: "GPT-5.4", isDefault: true }],
}),
]);
const providers = buildSelectableProviderSelectorProviders(
[
snapshotEntry({
provider: "codex",
label: "Codex",
models: [{ provider: "codex", id: "gpt-5.4", label: "GPT-5.4", isDefault: true }],
}),
],
{ selectedProvider: null },
);
expect(
resolveSelectedModelLabel({
@@ -348,15 +394,18 @@ describe("combined model selector data", () => {
});
it("keeps provider snapshot errors visible in the selected trigger label", () => {
const providers = buildSelectableProviderSelectorProviders([
snapshotEntry({
provider: "opencode",
label: "OpenCode",
status: "error",
error: "OpenCode app.agents timed out after 10s",
models: [],
}),
]);
const providers = buildSelectableProviderSelectorProviders(
[
snapshotEntry({
provider: "opencode",
label: "OpenCode",
status: "error",
error: "OpenCode app.agents timed out after 10s",
models: [],
}),
],
{ selectedProvider: null },
);
expect(
resolveSelectedModelLabel({
@@ -410,21 +459,27 @@ describe("combined model selector data", () => {
it("uses the active app language for utility labels", async () => {
await i18n.changeLanguage("zh-CN");
try {
const providers = buildSelectableProviderSelectorProviders([
snapshotEntry({
provider: "deepseek-tui",
label: "DeepSeek TUI",
models: [],
}),
snapshotEntry({
provider: "unavailable-provider",
status: "unavailable",
models: [],
}),
]);
const providers = buildSelectableProviderSelectorProviders(
[
snapshotEntry({
provider: "deepseek-tui",
label: "DeepSeek TUI",
models: [],
}),
],
{ selectedProvider: null },
);
expect(getAllModelLabels(providers)).toContain("默认");
expect(providers[1]?.modelSelection).toEqual({
expect(
buildSelectorProvider(
snapshotEntry({
provider: "unavailable-provider",
status: "unavailable",
models: [],
}),
).modelSelection,
).toEqual({
kind: "error",
message: "不可用",
});
@@ -143,20 +143,35 @@ export function buildProviderSelectorProviders(input: {
}));
}
/** One provider in a selector, whatever its state. */
export function buildSelectorProvider(
entry: ProviderSnapshotEntry,
isConnected = true,
): ProviderSelectorProvider {
const label = entry.label ?? entry.provider;
return {
id: entry.provider,
label,
modelSelection: buildEntryModelSelection(entry, label, isConnected),
};
}
/**
* The providers a user can pick a model from: enabled, and installed or still being probed. The
* provider of the picker's current choice stays whatever its state, so the selector still names
* it. Every picker says what that choice is, or `null` for none, so none can forget it.
*/
export function buildSelectableProviderSelectorProviders(
entries: ProviderSnapshotEntry[] | undefined,
isConnected = true,
options: { isConnected?: boolean; selectedProvider: string | null },
): ProviderSelectorProvider[] {
const { isConnected = true, selectedProvider } = options;
return (entries ?? [])
.filter((entry) => entry.enabled)
.map((entry) => {
const label = entry.label ?? entry.provider;
return {
id: entry.provider,
label,
modelSelection: buildEntryModelSelection(entry, label, isConnected),
};
});
.filter(
(entry) =>
entry.provider === selectedProvider || (entry.enabled && entry.status !== "unavailable"),
)
.map((entry) => buildSelectorProvider(entry, isConnected));
}
export function getProviderModelRows(
@@ -0,0 +1,4 @@
export { ProviderList } from "./internal/provider-list";
export { ProviderDetailPage } from "./internal/provider-detail-page";
export { ProviderDetailSheet } from "./internal/provider-detail-sheet";
export type { ProviderSheetFrame } from "./internal/sheet-frame";
@@ -0,0 +1,187 @@
import { PackagePlus } from "lucide-react-native";
import { useCallback, useMemo, useRef, useState } from "react";
import { useTranslation } from "react-i18next";
import { Text, View } from "react-native";
import { SvgXml } from "react-native-svg";
import { StyleSheet, withUnistyles } from "react-native-unistyles";
import { AdaptiveModalSheet, type SheetHeader } from "@/components/adaptive-modal-sheet";
import { rankProviderCatalog } from "@/components/provider-catalog-search";
import { SettingsCard, SettingsRow } from "@/components/settings";
import { Button } from "@/components/ui/button";
import {
useAcpProviderCatalog,
type AcpProviderCatalogItem,
} from "@/hooks/use-acp-provider-catalog";
import { useProvidersSnapshot } from "@/hooks/use-providers-snapshot";
import { settingsStyles } from "@/styles/settings";
import { ICON_SIZE, type Theme } from "@/styles/theme";
import { useProviderConfigActions } from "./provider-config";
import { OVERLAY_SHEET_FRAME, type ProviderSheetFrame } from "./sheet-frame";
const ThemedPackagePlus = withUnistyles(PackagePlus);
const ThemedSvgXml = withUnistyles(SvgXml);
const foregroundColorMapping = (theme: Theme) => ({ color: theme.colors.foreground });
export interface AddProviderSheetProps {
serverId: string;
visible: boolean;
onClose: () => void;
/** The provider is in config and listed; open its detail. */
onAdded: (providerId: string) => void;
frame?: ProviderSheetFrame;
}
/** The catalog of providers not added yet, searchable, each with Add. */
export function AddProviderSheet({
serverId,
visible,
onClose,
onAdded,
frame = OVERLAY_SHEET_FRAME,
}: AddProviderSheetProps) {
const { t } = useTranslation();
const { entries: catalog } = useAcpProviderCatalog();
const { entries: providers } = useProvidersSnapshot(serverId);
const { add, addingProviderId } = useProviderConfigActions(serverId);
const [search, setSearch] = useState("");
// Each opening starts from an empty search; the field clears when this changes.
const [session, setSession] = useState(0);
// Read when an add finishes, to tell whether the sheet it started in is still open.
const sessionRef = useRef(0);
const endSession = useCallback(() => {
setSearch("");
sessionRef.current += 1;
setSession(sessionRef.current);
}, []);
const handleClose = useCallback(() => {
endSession();
onClose();
}, [endSession, onClose]);
const available = useMemo(() => {
const added = new Set(providers?.map((entry) => entry.provider) ?? []);
return rankProviderCatalog(
catalog.filter((entry) => !added.has(entry.id)),
search,
);
}, [catalog, providers, search]);
const handleAdd = useCallback(
(entry: AcpProviderCatalogItem) => {
const startedIn = sessionRef.current;
void add(entry).then((added) => {
// Closed before the add finished: the provider is added, but the user has moved on.
if (!added || sessionRef.current !== startedIn) return added;
endSession();
onAdded(entry.id);
return added;
});
},
[add, endSession, onAdded],
);
const header = useMemo<SheetHeader>(
() => ({
title: t("settings.providers.addProvider"),
back: frame.returns
? {
onPress: handleClose,
accessibilityLabel: t("settings.providers.detail.backToProviders"),
}
: undefined,
search: {
onChange: setSearch,
placeholder: t("providerCatalog.search"),
resetKey: session,
testID: "provider-catalog-search",
},
}),
[frame.returns, handleClose, session, t],
);
return (
<AdaptiveModalSheet
header={header}
visible={visible}
onClose={handleClose}
showCloseButton={!frame.returns}
desktopMaxWidth={frame.desktopMaxWidth}
desktopHeight={frame.desktopHeight}
snapPoints={frame.snapPoints}
testID="add-provider-sheet"
>
<SettingsCard>
{available.length === 0 ? (
<View style={settingsStyles.row}>
<Text style={styles.empty}>{t("providerCatalog.noProviders")}</Text>
</View>
) : (
available.map((entry) => (
<CatalogRow
key={entry.id}
entry={entry}
adding={addingProviderId === entry.id}
disabled={addingProviderId !== null}
onAdd={handleAdd}
/>
))
)}
</SettingsCard>
</AdaptiveModalSheet>
);
}
function CatalogRow({
entry,
adding,
disabled,
onAdd,
}: {
entry: AcpProviderCatalogItem;
adding: boolean;
disabled: boolean;
onAdd: (entry: AcpProviderCatalogItem) => void;
}) {
const { t } = useTranslation();
const handleAdd = useCallback(() => onAdd(entry), [entry, onAdd]);
const icon = useMemo(
() =>
entry.iconSvg ? (
<ThemedSvgXml
xml={entry.iconSvg}
width={ICON_SIZE.md}
height={ICON_SIZE.md}
uniProps={foregroundColorMapping}
/>
) : (
<ThemedPackagePlus size={ICON_SIZE.md} uniProps={foregroundColorMapping} />
),
[entry.iconSvg],
);
return (
<SettingsRow
leading={icon}
label={entry.title}
hint={entry.description}
testID={`provider-catalog-row-${entry.id}`}
>
<Button
variant="outline"
onPress={handleAdd}
loading={adding}
disabled={disabled}
accessibilityLabel={t("providerCatalog.actions.addProvider", { provider: entry.title })}
testID={`install-provider-${entry.id}`}
>
{adding ? t("providerCatalog.actions.adding") : t("providerCatalog.actions.add")}
</Button>
</SettingsRow>
);
}
const styles = StyleSheet.create((theme) => ({
empty: {
color: theme.colors.foregroundMuted,
fontSize: theme.fontSize.base,
},
}));
@@ -0,0 +1,249 @@
import { describe, expect, it } from "vitest";
import type { ProviderSnapshotEntry } from "@getpaseo/protocol/agent-types";
import type { ProviderInstallationState } from "@/components/provider-installation-section";
import { readDetailPresence, readDetailSections, readShownInstallation } from "./detail-sections";
function entry(overrides: Partial<ProviderSnapshotEntry> = {}): ProviderSnapshotEntry {
return {
provider: "opencode",
label: "OpenCode",
status: "ready",
enabled: true,
modes: [],
models: [],
...overrides,
};
}
const unsupported: ProviderInstallationState = { status: "unsupported" };
const notInstalled: ProviderInstallationState = {
status: "ready",
installation: { inspection: { status: "not_installed" }, canUpdate: false },
};
describe("provider detail sections", () => {
it("shows every model for a provider that runs", () => {
expect(readDetailSections(entry(), unsupported)).toEqual({ error: null, models: "all" });
});
it("keeps every model while the provider is probed again", () => {
expect(readDetailSections(entry({ status: "loading" }), unsupported).models).toBe("all");
});
it("leads with the error and keeps custom models when the provider fails", () => {
expect(
readDetailSections(
entry({ status: "error", error: "opencode exited with code 1" }),
unsupported,
),
).toEqual({ error: "opencode exited with code 1", models: "custom" });
});
it("says nothing extra and lists no models when Installation already says Not installed", () => {
expect(readDetailSections(entry({ status: "unavailable" }), unsupported)).toEqual({
error: null,
models: null,
});
expect(
readDetailSections(entry({ status: "error", error: "spawn ENOENT" }), notInstalled),
).toEqual({ error: null, models: null });
});
it("hides models and the error for a disabled provider", () => {
expect(
readDetailSections(entry({ enabled: false, status: "error", error: "boom" }), unsupported),
).toEqual({ error: null, models: null });
});
it("gives an error with no message an empty one, so the alert still shows", () => {
expect(readDetailSections(entry({ status: "error" }), unsupported).error).toBe("");
});
});
describe("provider detail installation", () => {
const guide = "https://example.com/install";
const noContract: ProviderInstallationState = { status: "ready", installation: null };
it("says Not installed with the install guide when the host reports nothing about it", () => {
expect(
readShownInstallation({
entry: entry({ status: "unavailable" }),
installation: noContract,
installGuide: guide,
}),
).toEqual({
status: "ready",
installation: { inspection: { status: "not_installed" }, installUrl: guide },
});
});
it("keeps the host's install link over the guide", () => {
const hosted: ProviderInstallationState = {
status: "ready",
installation: {
inspection: { status: "not_installed" },
installUrl: "https://host.example/install",
canUpdate: false,
},
};
expect(
readShownInstallation({
entry: entry({ status: "unavailable" }),
installation: hosted,
installGuide: guide,
}),
).toEqual(hosted);
});
it("gives the host's Not installed the guide when the host has no link", () => {
expect(
readShownInstallation({
entry: entry({ status: "unavailable" }),
installation: notInstalled,
installGuide: guide,
}),
).toEqual({
status: "ready",
installation: {
inspection: { status: "not_installed" },
canUpdate: false,
installUrl: guide,
},
});
});
it("adds nothing for an installed or disabled provider", () => {
expect(
readShownInstallation({ entry: entry(), installation: noContract, installGuide: guide }),
).toEqual(noContract);
expect(
readShownInstallation({
entry: entry({ enabled: false, status: "unavailable" }),
installation: noContract,
installGuide: guide,
}),
).toEqual(noContract);
});
it("says nothing it cannot back with a guide", () => {
expect(
readShownInstallation({
entry: entry({ status: "unavailable" }),
installation: noContract,
installGuide: null,
}),
).toEqual(noContract);
});
it("says Not installed with the guide on a host that cannot report installations", () => {
expect(
readShownInstallation({
entry: entry({ status: "unavailable" }),
installation: unsupported,
installGuide: guide,
}),
).toEqual({
status: "ready",
installation: { inspection: { status: "not_installed" }, installUrl: guide },
});
// Without a guide, or for a provider the host runs, there is nothing to show.
expect(
readShownInstallation({
entry: entry({ status: "unavailable" }),
installation: unsupported,
installGuide: null,
}),
).toEqual(unsupported);
expect(
readShownInstallation({ entry: entry(), installation: unsupported, installGuide: guide }),
).toEqual(unsupported);
});
it("waits while the host is still checking", () => {
const checking: ProviderInstallationState = { status: "loading" };
expect(
readShownInstallation({
entry: entry({ status: "unavailable" }),
installation: checking,
installGuide: guide,
}),
).toEqual(checking);
});
});
describe("provider detail presence", () => {
const loaded = [entry(), entry({ provider: "codex", label: "Codex" })];
it("finds the provider among the host's providers", () => {
expect(
readDetailPresence({
provider: "codex",
connected: true,
entries: loaded,
error: null,
removing: null,
}),
).toEqual({ kind: "found", entry: loaded[1] });
});
it("is loading until the host's providers arrive", () => {
expect(
readDetailPresence({
provider: "codex",
connected: true,
entries: undefined,
error: null,
removing: null,
}),
).toEqual({ kind: "loading" });
});
it("says the provider is missing once the host's providers have arrived without it", () => {
expect(
readDetailPresence({
provider: "gone",
connected: true,
entries: loaded,
error: null,
removing: null,
}),
).toEqual({ kind: "missing" });
});
it("keeps showing a provider this page is removing once it leaves the list", () => {
const gone = entry({ provider: "gone", label: "Gone" });
expect(
readDetailPresence({
provider: "gone",
connected: true,
entries: loaded,
error: null,
removing: gone,
}),
).toEqual({ kind: "found", entry: gone });
});
it("says the host is offline rather than loading forever", () => {
expect(
readDetailPresence({
provider: "codex",
connected: false,
entries: undefined,
error: null,
removing: null,
}),
).toEqual({ kind: "offline" });
});
it("shows why the host's providers could not be read", () => {
expect(
readDetailPresence({
provider: "codex",
connected: true,
entries: undefined,
error: "Request timed out",
removing: null,
}),
).toEqual({ kind: "failed", message: "Request timed out" });
});
});
@@ -0,0 +1,97 @@
import type { ProviderSnapshotEntry } from "@getpaseo/protocol/agent-types";
import type { ProviderInstallationState } from "@/components/provider-installation-section";
export interface DetailSections {
/** The failure the page leads with, or null. Empty when the provider gave no message. */
error: string | null;
/**
* Which models the page lists. The provider reports its own only while it runs; custom models
* live in config, so they stay manageable while it fails.
*/
models: "all" | "custom" | null;
}
/** Which of the detail's state-dependent parts show, so each fact is said once. */
export function readDetailSections(
entry: ProviderSnapshotEntry,
installation: ProviderInstallationState,
): DetailSections {
const notInstalled =
entry.status === "unavailable" ||
(installation.status === "ready" &&
installation.installation?.inspection?.status === "not_installed");
const failing = entry.enabled && entry.status === "error" && !notInstalled;
return {
error: failing ? (entry.error?.trim() ?? "") : null,
models: readShownModels(entry, notInstalled),
};
}
function readShownModels(
entry: ProviderSnapshotEntry,
notInstalled: boolean,
): DetailSections["models"] {
if (!entry.enabled || notInstalled) return null;
return entry.status === "error" ? "custom" : "all";
}
/**
* The installation the page shows. A provider added from the catalog has no installation the
* host can report, so when its CLI is missing the page says so with the catalog's install guide.
* The host's own install link wins over the guide. A host that cannot report installations gets
* the same row, because the guide is the app's own catalog data.
*/
export function readShownInstallation(input: {
entry: ProviderSnapshotEntry;
installation: ProviderInstallationState;
/** The catalog's install guide for this provider, or null. */
installGuide: string | null;
}): ProviderInstallationState {
const { entry, installation, installGuide } = input;
if (!installGuide) return installation;
if (installation.status !== "ready" && installation.status !== "unsupported") return installation;
const reported = installation.status === "ready" ? installation.installation : null;
if (reported?.installUrl) return installation;
const notInstalled =
reported?.inspection?.status === "not_installed" ||
(!reported?.inspection && entry.enabled && entry.status === "unavailable");
if (!notInstalled) return installation;
return {
status: "ready",
installation: {
...reported,
inspection: { status: "not_installed" },
installUrl: installGuide,
},
};
}
export type DetailPresence =
| { kind: "found"; entry: ProviderSnapshotEntry }
| { kind: "loading" }
| { kind: "missing" }
| { kind: "offline" }
| { kind: "failed"; message: string };
/**
* Whether the page has a provider to show. A page opened from its URL renders before the host's
* providers arrive, and its id may name a provider the host no longer has. A provider this page is
* removing leaves the list before the removal answers; the page keeps showing it until it closes.
*/
export function readDetailPresence(input: {
provider: string;
connected: boolean;
entries: ProviderSnapshotEntry[] | undefined;
error: string | null;
/** The provider this page's own Remove is deleting, as it was when the user confirmed. */
removing: ProviderSnapshotEntry | null;
}): DetailPresence {
const entry =
input.entries?.find((candidate) => candidate.provider === input.provider) ??
(input.removing?.provider === input.provider ? input.removing : undefined);
if (entry) return { kind: "found", entry };
if (!input.connected) return { kind: "offline" };
if (input.entries) return { kind: "missing" };
if (input.error) return { kind: "failed", message: input.error };
return { kind: "loading" };
}
@@ -0,0 +1,149 @@
import * as Clipboard from "expo-clipboard";
import { Copy, RotateCw } from "lucide-react-native";
import { useCallback, useEffect, useMemo, useState } from "react";
import { useTranslation } from "react-i18next";
import { Text, View } from "react-native";
import { StyleSheet, withUnistyles } from "react-native-unistyles";
import {
AdaptiveModalSheet,
SheetHeaderIconButton,
type SheetHeader,
} from "@/components/adaptive-modal-sheet";
import { LoadingSpinner } from "@/components/ui/loading-spinner";
import { ScrollableCodeSurface, SurfaceCard } from "@/components/ui/scrollable-code-surface";
import { useToast } from "@/contexts/toast-context";
import { useHostRuntimeClient } from "@/runtime/host-runtime";
import type { Theme } from "@/styles/theme";
const ThemedLoadingSpinner = withUnistyles(LoadingSpinner);
const mutedColorMapping = (theme: Theme) => ({ color: theme.colors.foregroundMuted });
const DIAGNOSTIC_SNAP_POINTS = ["50%", "85%"];
/** The provider's diagnostic report, run on open, with copy and run again. */
export function DiagnosticSheet({
serverId,
provider,
visible,
onClose,
}: {
serverId: string;
provider: string;
visible: boolean;
onClose: () => void;
}) {
const { t } = useTranslation();
const toast = useToast();
const client = useHostRuntimeClient(serverId);
const [diagnostic, setDiagnostic] = useState<string | null>(null);
const [loading, setLoading] = useState(false);
const fetchDiagnostic = useCallback(async () => {
if (!client) return;
setLoading(true);
try {
const result = await client.getProviderDiagnostic(provider);
setDiagnostic(result.diagnostic);
} catch (err) {
setDiagnostic(
err instanceof Error ? err.message : t("settings.providers.diagnostic.failedToFetch"),
);
} finally {
setLoading(false);
}
}, [client, provider, t]);
useEffect(() => {
if (visible) {
void fetchDiagnostic();
} else {
setDiagnostic(null);
}
}, [visible, fetchDiagnostic]);
const handleRefresh = useCallback(() => {
if (loading) return;
void fetchDiagnostic();
}, [fetchDiagnostic, loading]);
const handleCopy = useCallback(() => {
if (!diagnostic) return;
void Clipboard.setStringAsync(diagnostic)
.then(() => toast.copied(t("settings.providers.diagnostic.copyLabel")))
.catch(() => toast.error(t("settings.providers.diagnostic.copyFailed")));
}, [diagnostic, t, toast]);
const header = useMemo<SheetHeader>(
() => ({
title: t("settings.providers.diagnostic.title"),
actions: (
<>
<SheetHeaderIconButton
icon={Copy}
label={t("settings.providers.diagnostic.copyAccessibility")}
onPress={handleCopy}
disabled={!diagnostic}
/>
<SheetHeaderIconButton
icon={RotateCw}
label={
loading
? t("settings.providers.diagnostic.refreshingAccessibility")
: t("settings.providers.diagnostic.refreshAccessibility")
}
onPress={handleRefresh}
busy={loading}
/>
</>
),
}),
[diagnostic, handleCopy, handleRefresh, loading, t],
);
let body: React.ReactNode;
if (loading && !diagnostic) {
body = (
<SurfaceCard>
<View style={styles.placeholder}>
<ThemedLoadingSpinner size="small" uniProps={mutedColorMapping} />
<Text style={styles.mutedText}>{t("settings.providers.diagnostic.running")}</Text>
</View>
</SurfaceCard>
);
} else if (diagnostic) {
body = <ScrollableCodeSurface maxHeight={480}>{diagnostic}</ScrollableCodeSurface>;
} else {
body = (
<SurfaceCard>
<View style={styles.placeholder}>
<Text style={styles.mutedText}>{t("settings.providers.diagnostic.none")}</Text>
</View>
</SurfaceCard>
);
}
return (
<AdaptiveModalSheet
header={header}
visible={visible}
onClose={onClose}
snapPoints={DIAGNOSTIC_SNAP_POINTS}
scrollable={false}
testID="provider-diagnostic-sheet"
>
{body}
</AdaptiveModalSheet>
);
}
const styles = StyleSheet.create((theme) => ({
placeholder: {
paddingVertical: theme.spacing[4],
paddingHorizontal: theme.spacing[4],
flexDirection: "row",
alignItems: "center",
gap: theme.spacing[2],
},
mutedText: {
fontSize: theme.fontSize.base,
color: theme.colors.foregroundMuted,
},
}));
@@ -3,7 +3,7 @@ import type { AgentModelDefinition } from "@getpaseo/protocol/agent-types";
import {
resolveProviderDiscoveredModels,
type ProviderDiscoveredModelsCache,
} from "./provider-diagnostic-models";
} from "./discovered-models";
const piModel: AgentModelDefinition = {
provider: "pi",
@@ -0,0 +1,151 @@
import { useCallback, useRef, useState } from "react";
import { useTranslation } from "react-i18next";
import { Alert } from "react-native";
import { useToast } from "@/contexts/toast-api-context";
import { useDaemonConfig } from "@/hooks/use-daemon-config";
import {
buildAcpProviderConfigPatch,
getAcpProviderCatalog,
type AcpProviderCatalogItem,
} from "@/hooks/use-acp-provider-catalog";
import { useProvidersSnapshot } from "@/hooks/use-providers-snapshot";
import { selectHostFeature, useHostFeature } from "@/runtime/host-features";
import { useSessionStore } from "@/stores/session-store";
import { confirmDialog } from "@/utils/confirm-dialog";
export type ProviderEntry = NonNullable<ReturnType<typeof useProvidersSnapshot>["entries"]>[number];
export interface ProviderConfigActions {
/** The provider whose Enabled switch is being saved. */
togglingProviderId: string | null;
setEnabled: (providerId: string, enabled: boolean) => void;
/** Config owns the provider, so Remove can delete it. */
canRemove: (entry: ProviderEntry) => boolean;
/**
* The provider being removed, as it was when the user confirmed. It stays set once the removal
* succeeds, because whatever shows the provider closes next and keeps showing it until then, and
* ends when the host lists the provider again, as when the user adds it back.
*/
removing: ProviderEntry | null;
/** Asks first; resolves true once the provider is gone from config. */
remove: (entry: ProviderEntry, providerLabel: string) => Promise<boolean>;
/** The catalog provider being written to config. */
addingProviderId: string | null;
/** Writes a catalog provider to config and probes it; resolves true once it is listed. */
add: (entry: AcpProviderCatalogItem) => Promise<boolean>;
}
/** Writes a provider's Enabled flag, adds catalog providers and removes config-owned ones. */
export function useProviderConfigActions(serverId: string): ProviderConfigActions {
const { t } = useTranslation();
const toast = useToast();
const { config, patchConfig } = useDaemonConfig(serverId);
const { entries, refresh } = useProvidersSnapshot(serverId);
const supportsProviderRemoval = useHostFeature(serverId, "providerRemoval");
const [togglingProviderId, setTogglingProviderId] = useState<string | null>(null);
const [removal, setRemoval] = useState<{ entry: ProviderEntry; done: boolean } | null>(null);
const removingRef = useRef<string | null>(null);
const [addingProviderId, setAddingProviderId] = useState<string | null>(null);
const addingRef = useRef<string | null>(null);
const setEnabled = useCallback(
(providerId: string, enabled: boolean) => {
setTogglingProviderId(providerId);
void patchConfig({ providers: { [providerId]: { enabled } } })
.catch((error: unknown) => {
Alert.alert(
t("settings.providers.updateErrorTitle"),
error instanceof Error ? error.message : String(error),
);
})
.finally(() => {
setTogglingProviderId((current) => (current === providerId ? null : current));
});
},
[patchConfig, t],
);
// Config owns derived providers and the opt-in bundled catalog providers.
const canRemove = useCallback(
(entry: ProviderEntry) => {
const providerConfig = config?.providers?.[entry.provider];
if (!supportsProviderRemoval || entry.source !== "custom" || !providerConfig) return false;
return Boolean(
providerConfig.extends ||
getAcpProviderCatalog().some(
(catalogEntry) => catalogEntry.id === entry.provider && catalogEntry.bundledProvider,
),
);
},
[config, supportsProviderRemoval],
);
const remove = useCallback(
async (entry: ProviderEntry, providerLabel: string) => {
if (removingRef.current) return false;
removingRef.current = entry.provider;
try {
const confirmed = await confirmDialog({
title: t("settings.providers.remove.confirmTitle", { name: providerLabel }),
message: t("settings.providers.remove.confirmMessage"),
confirmLabel: t("settings.providers.remove.confirm"),
destructive: true,
});
if (!confirmed) return false;
setRemoval({ entry, done: false });
await patchConfig({ removeProviders: [entry.provider] });
setRemoval({ entry, done: true });
return true;
} catch (error) {
setRemoval(null);
Alert.alert(
t("settings.providers.remove.errorTitle"),
error instanceof Error ? error.message : String(error),
);
return false;
} finally {
removingRef.current = null;
}
},
[patchConfig, t],
);
// A sheet outlives each opening, so a finished removal ends here rather than with the sheet.
if (removal?.done && entries?.some((entry) => entry.provider === removal.entry.provider)) {
setRemoval(null);
}
const add = useCallback(
async (entry: AcpProviderCatalogItem) => {
if (addingRef.current) return false;
addingRef.current = entry.id;
setAddingProviderId(entry.id);
try {
await patchConfig(
buildAcpProviderConfigPatch(entry, (feature) =>
selectHostFeature(useSessionStore.getState(), serverId, feature),
),
);
await refresh([entry.id]);
return true;
} catch (error) {
toast.error(error instanceof Error ? error.message : String(error));
return false;
} finally {
if (addingRef.current === entry.id) addingRef.current = null;
setAddingProviderId((current) => (current === entry.id ? null : current));
}
},
[patchConfig, refresh, serverId, toast],
);
return {
togglingProviderId,
setEnabled,
canRemove,
removing: removal?.entry ?? null,
remove,
addingProviderId,
add,
};
}
@@ -0,0 +1,49 @@
import { useMemo } from "react";
import { useTranslation } from "react-i18next";
import { View } from "react-native";
import { SettingsDetailHeader } from "@/components/settings";
import { ProviderDetail, useProviderDetail } from "./provider-detail";
import { ProviderGlyph } from "./provider-glyph";
/**
* A provider's detail as a Settings page, shaped like a project's: the screen titles it
* "Providers", the page names the provider. On wide layouts the page has no back button of its
* own, so it draws "Back to providers".
*/
export function ProviderDetailPage({
serverId,
provider,
onBack,
showBack,
}: {
serverId: string;
provider: string;
onBack: () => void;
showBack: boolean;
}) {
const { t } = useTranslation();
const detail = useProviderDetail({ serverId, provider, onRemoved: onBack });
const back = useMemo(
() => ({
label: t("settings.providers.detail.backToProviders"),
onPress: onBack,
testID: "provider-detail-back",
}),
[onBack, t],
);
const icon = useMemo(
() => <ProviderGlyph serverId={serverId} provider={provider} />,
[provider, serverId],
);
return (
<View testID="provider-detail-page">
<SettingsDetailHeader
back={showBack ? back : undefined}
icon={icon}
title={detail.label}
titleTestID="provider-detail-title"
/>
<ProviderDetail serverId={serverId} detail={detail} />
</View>
);
}
@@ -0,0 +1,52 @@
import { useMemo } from "react";
import { useTranslation } from "react-i18next";
import { AdaptiveModalSheet, type SheetHeader } from "@/components/adaptive-modal-sheet";
import { ProviderDetail, useProviderDetail } from "./provider-detail";
import { ProviderGlyph } from "./provider-glyph";
import { OVERLAY_SHEET_FRAME, type ProviderSheetFrame } from "./sheet-frame";
/** A provider's detail as a sheet, for surfaces with no Settings route to push. */
export function ProviderDetailSheet({
serverId,
provider,
visible,
onClose,
frame = OVERLAY_SHEET_FRAME,
}: {
serverId: string;
provider: string;
visible: boolean;
onClose: () => void;
frame?: ProviderSheetFrame;
}) {
const { t } = useTranslation();
const detail = useProviderDetail({ serverId, provider, onRemoved: onClose });
const label = detail.label;
const header = useMemo<SheetHeader>(
() => ({
title: label,
leading: <ProviderGlyph serverId={serverId} provider={provider} />,
back: frame.returns
? {
onPress: onClose,
accessibilityLabel: t("settings.providers.detail.backToProviders"),
}
: undefined,
}),
[frame.returns, label, onClose, provider, serverId, t],
);
return (
<AdaptiveModalSheet
header={header}
showCloseButton={!frame.returns}
visible={visible}
onClose={onClose}
snapPoints={frame.snapPoints}
desktopMaxWidth={frame.desktopMaxWidth}
desktopHeight={frame.desktopHeight}
testID="provider-settings-sheet"
>
<ProviderDetail serverId={serverId} detail={detail} />
</AdaptiveModalSheet>
);
}
@@ -0,0 +1,255 @@
import { useCallback, useState } from "react";
import { useTranslation } from "react-i18next";
import { View } from "react-native";
import { ProviderInstallationSection } from "@/components/provider-installation-section";
import { useProviderInstallation } from "@/components/provider-installation";
import {
SettingsCard,
SettingsDetailRow,
SettingsRow,
SettingsSection,
SettingsSwitch,
} from "@/components/settings";
import { Alert } from "@/components/ui/alert";
import { Button } from "@/components/ui/button";
import { readAcpProviderInstallGuide } from "@/hooks/use-acp-provider-catalog";
import { useProvidersSnapshot } from "@/hooks/use-providers-snapshot";
import { useTimeAgo } from "@/hooks/use-time-ago";
import { useHostRuntimeIsConnected } from "@/runtime/host-runtime";
import { settingsStyles } from "@/styles/settings";
import {
readDetailPresence,
readDetailSections,
readShownInstallation,
type DetailPresence,
} from "./detail-sections";
import { DiagnosticSheet } from "./diagnostic-sheet";
import { useProviderConfigActions, type ProviderEntry } from "./provider-config";
import { ProviderModels } from "./provider-models";
import { ProviderNotice } from "./provider-notice";
export interface ProviderDetailState {
provider: string;
/** The provider's name, kept while this page removes it. */
label: string;
presence: DetailPresence;
/** Config owns the provider, so Remove can delete it. */
canRemove: (entry: ProviderEntry) => boolean;
/** This page's Remove is running, or has succeeded and the page is closing. */
removing: boolean;
remove: () => void;
}
/**
* What a provider's detail shows and its Remove, shared by the frame's title and the body. A
* provider this page removes leaves the host's list before the removal answers; both keep showing
* it until the frame closes.
*/
export function useProviderDetail({
serverId,
provider,
onRemoved,
}: {
serverId: string;
provider: string;
/** The provider was removed; leave its detail. */
onRemoved: () => void;
}): ProviderDetailState {
const { entries, error } = useProvidersSnapshot(serverId);
const connected = useHostRuntimeIsConnected(serverId);
const { canRemove, remove, removing } = useProviderConfigActions(serverId);
const presence = readDetailPresence({ provider, connected, entries, error, removing });
const shown = presence.kind === "found" ? presence.entry : null;
const label = shown?.label ?? provider;
const handleRemove = useCallback(() => {
if (!shown) return;
void remove(shown, label).then((removed) => {
if (removed) onRemoved();
return removed;
});
}, [label, onRemoved, remove, shown]);
return {
provider,
label,
presence,
canRemove,
removing: removing?.provider === provider,
remove: handleRemove,
};
}
/**
* Everything about one provider, top to bottom: what is wrong, whether it runs, its installation,
* its models, then the rare actions. The page and the sheet frame the same body.
*/
export function ProviderDetail({
serverId,
detail,
}: {
serverId: string;
detail: ProviderDetailState;
}) {
const { provider, presence, label } = detail;
const { refresh, isRefreshing } = useProvidersSnapshot(serverId);
const installation = useProviderInstallation({ serverId, provider, visible: true });
const refreshInstallation = installation.refresh;
const handleRefresh = useCallback(() => {
void refresh([provider]);
refreshInstallation();
}, [provider, refresh, refreshInstallation]);
if (presence.kind !== "found") return <AbsentProvider presence={presence} />;
const entry = presence.entry;
const shownInstallation = readShownInstallation({
entry,
installation: installation.state,
installGuide: readAcpProviderInstallGuide(provider),
});
const sections = readDetailSections(entry, shownInstallation);
return (
<View testID="provider-detail">
{sections.error !== null ? <ProviderErrorAlert label={label} error={sections.error} /> : null}
<EnabledCard serverId={serverId} entry={entry} />
<ProviderInstallationSection
state={shownInstallation}
updates={installation.updates}
action={installation.action}
/>
{sections.models ? (
<ProviderModels
serverId={serverId}
entry={entry}
discovered={sections.models === "all"}
refresh={refresh}
/>
) : null}
<Troubleshooting
serverId={serverId}
entry={entry}
refreshing={isRefreshing || installation.refreshing}
onRefresh={handleRefresh}
/>
{/* Config no longer owns a provider whose removal has succeeded. */}
{detail.removing || detail.canRemove(entry) ? (
<DangerZone removing={detail.removing} onRemove={detail.remove} />
) : null}
</View>
);
}
function AbsentProvider({ presence }: { presence: Exclude<DetailPresence, { kind: "found" }> }) {
const { t } = useTranslation();
const messages = {
loading: t("settings.providers.loading"),
missing: t("settings.providers.detail.notOnHost"),
offline: t("settings.providers.unavailable"),
};
const message = presence.kind === "failed" ? presence.message : messages[presence.kind];
return <ProviderNotice message={message} testID={`provider-detail-${presence.kind}`} />;
}
function ProviderErrorAlert({ label, error }: { label: string; error: string }) {
const { t } = useTranslation();
return (
<View style={settingsStyles.section}>
<Alert
variant="error"
title={t("settings.providers.detail.unavailableTitle", { name: label })}
description={error || t("settings.providers.diagnostic.unknownError")}
testID="provider-error"
/>
</View>
);
}
function EnabledCard({ serverId, entry }: { serverId: string; entry: ProviderEntry }) {
const { t } = useTranslation();
const { setEnabled, togglingProviderId } = useProviderConfigActions(serverId);
const handleChange = useCallback(
(enabled: boolean) => setEnabled(entry.provider, enabled),
[entry.provider, setEnabled],
);
return (
<View style={settingsStyles.section}>
<SettingsCard>
<SettingsSwitch
label={t("settings.providers.detail.enabled")}
value={entry.enabled}
onValueChange={handleChange}
disabled={togglingProviderId === entry.provider}
/>
</SettingsCard>
</View>
);
}
function Troubleshooting({
serverId,
entry,
refreshing,
onRefresh,
}: {
serverId: string;
entry: ProviderEntry;
refreshing: boolean;
onRefresh: () => void;
}) {
const { t } = useTranslation();
const [diagnosticOpen, setDiagnosticOpen] = useState(false);
const openDiagnostic = useCallback(() => setDiagnosticOpen(true), []);
const closeDiagnostic = useCallback(() => setDiagnosticOpen(false), []);
const checked = useTimeAgo(entry.fetchedAt ? new Date(entry.fetchedAt) : null);
// The probe running again is a refresh too, whoever asked for it.
const busy = refreshing || entry.status === "loading";
return (
<SettingsSection title={t("settings.providers.detail.troubleshooting")}>
<SettingsCard>
<SettingsRow
label={t("settings.providers.detail.status")}
hint={
entry.fetchedAt ? t("settings.providers.detail.checked", { time: checked }) : undefined
}
>
<Button variant="outline" onPress={onRefresh} loading={busy} testID="provider-refresh">
{busy
? t("settings.providers.diagnostic.refreshing")
: t("settings.providers.diagnostic.refresh")}
</Button>
</SettingsRow>
<SettingsDetailRow
label={t("settings.providers.detail.diagnosticReport")}
onPress={openDiagnostic}
testID="provider-diagnostic-report"
/>
</SettingsCard>
<DiagnosticSheet
serverId={serverId}
provider={entry.provider}
visible={diagnosticOpen}
onClose={closeDiagnostic}
/>
</SettingsSection>
);
}
function DangerZone({ removing, onRemove }: { removing: boolean; onRemove: () => void }) {
const { t } = useTranslation();
return (
<SettingsSection title={t("settings.providers.detail.dangerZone")}>
<SettingsCard>
<SettingsRow
label={t("settings.providers.actions.remove")}
hint={t("settings.providers.detail.removeHint")}
>
<Button variant="outline" onPress={onRemove} loading={removing} testID="provider-remove">
{removing
? t("settings.providers.actions.removing")
: t("settings.providers.remove.confirm")}
</Button>
</SettingsRow>
</SettingsCard>
</SettingsSection>
);
}
@@ -0,0 +1,13 @@
import { StyleSheet } from "react-native-unistyles";
import { useProviderIcon } from "@/components/provider-icons";
import { ICON_SIZE } from "@/styles/theme";
/** A provider's icon at row size, drawn in the foreground colour. */
export function ProviderGlyph({ serverId, provider }: { serverId: string; provider: string }) {
const Icon = useProviderIcon(provider, serverId);
return <Icon size={ICON_SIZE.md} color={styles.glyph.color} />;
}
const styles = StyleSheet.create((theme) => ({
glyph: { color: theme.colors.foreground },
}));
@@ -0,0 +1,206 @@
import { Plus } from "lucide-react-native";
import { useCallback, useMemo, useState } from "react";
import { useTranslation } from "react-i18next";
import { View } from "react-native";
import { StyleSheet } from "react-native-unistyles";
import { useProviderInstallation } from "@/components/provider-installation";
import { SettingsAddRow, SettingsCard, SettingsSection } from "@/components/settings";
import { Button } from "@/components/ui/button";
import { SkeletonPulse, useSkeletonPulse } from "@/components/ui/skeleton";
import { useProvidersSnapshot } from "@/hooks/use-providers-snapshot";
import { useHostRuntimeIsConnected } from "@/runtime/host-runtime";
import { settingsStyles } from "@/styles/settings";
import { buildProviderDefinitions } from "@/utils/provider-definitions";
import { AddProviderSheet } from "./add-provider-sheet";
import { useProviderConfigActions, type ProviderEntry } from "./provider-config";
import { ProviderGlyph } from "./provider-glyph";
import { ProviderNotice } from "./provider-notice";
import { ProviderRow } from "./provider-row";
import { readRowSummary } from "./row-summary";
import type { ProviderSheetFrame } from "./sheet-frame";
export interface ProviderListProps {
serverId: string;
/** Opens a provider's detail wherever the host shows it: a Settings page or a sheet. */
onOpenProvider: (providerId: string) => void;
/** Where the sheets the list opens sit. Defaults to a sheet over the current screen. */
sheetFrame?: ProviderSheetFrame;
}
/** The host's providers, each saying how it is, and the way to add one. */
export function ProviderList({ serverId, onOpenProvider, sheetFrame }: ProviderListProps) {
const { t } = useTranslation();
const isConnected = useHostRuntimeIsConnected(serverId) && serverId.length > 0;
const { entries, isLoading } = useProvidersSnapshot(serverId);
const { setEnabled, togglingProviderId } = useProviderConfigActions(serverId);
const definitions = useMemo(() => buildProviderDefinitions(entries), [entries]);
const [adding, setAdding] = useState(false);
const openAdd = useCallback(() => setAdding(true), []);
const closeAdd = useCallback(() => setAdding(false), []);
const handleAdded = useCallback(
(providerId: string) => {
setAdding(false);
onOpenProvider(providerId);
},
[onOpenProvider],
);
const addButton = useMemo(
() =>
isConnected ? (
<Button
variant="ghost"
leftIcon={Plus}
onPress={openAdd}
accessibilityLabel={t("settings.providers.addProvider")}
testID="provider-list-add"
>
{t("settings.providers.list.add")}
</Button>
) : null,
[isConnected, openAdd, t],
);
let body: React.ReactNode;
if (!isConnected) {
body = <ProviderNotice message={t("settings.providers.unavailable")} />;
} else if (isLoading) {
body = <ProviderRowsSkeleton />;
} else {
body = (
<SettingsCard testID="provider-list">
{definitions.map((definition) => {
const entry = entries?.find((candidate) => candidate.provider === definition.id);
if (!entry) return null;
return (
<ListedProvider
key={definition.id}
serverId={serverId}
entry={entry}
label={definition.label}
toggling={togglingProviderId === definition.id}
onOpen={onOpenProvider}
onToggle={setEnabled}
/>
);
})}
<SettingsAddRow
label={t("settings.providers.addProvider")}
onPress={openAdd}
testID="provider-list-add-row"
/>
</SettingsCard>
);
}
return (
<>
<SettingsSection
title={t("settings.providers.title")}
trailing={addButton}
testID="host-page-providers-card"
>
{body}
</SettingsSection>
{isConnected ? (
<AddProviderSheet
serverId={serverId}
visible={adding}
onClose={closeAdd}
onAdded={handleAdded}
frame={sheetFrame}
/>
) : null}
</>
);
}
/** A row reads its provider's installation itself; the detail shares the same requests. */
function ListedProvider({
serverId,
entry,
label,
toggling,
onOpen,
onToggle,
}: {
serverId: string;
entry: ProviderEntry;
label: string;
toggling: boolean;
onOpen: (provider: string) => void;
onToggle: (provider: string, enabled: boolean) => void;
}) {
const installation = useProviderInstallation({
serverId,
provider: entry.provider,
visible: true,
});
const icon = useMemo(
() => <ProviderGlyph serverId={serverId} provider={entry.provider} />,
[entry.provider, serverId],
);
return (
<ProviderRow
provider={entry.provider}
label={label}
icon={icon}
summary={readRowSummary(entry, installation)}
enabled={entry.enabled}
toggling={toggling}
onOpen={onOpen}
onToggle={onToggle}
/>
);
}
const SKELETON_ROW_KEYS = [0, 1, 2, 3].map((index) => `provider-skeleton-row-${index}`);
function ProviderRowsSkeleton() {
const { t } = useTranslation();
const pulse = useSkeletonPulse();
return (
<View
style={settingsStyles.card}
accessibilityLabel={t("settings.providers.loading")}
testID="providers-skeleton"
>
{SKELETON_ROW_KEYS.map((key, index) => (
<View key={key} style={[settingsStyles.row, index > 0 && settingsStyles.rowBorder]}>
<View style={styles.skeletonContent}>
<SkeletonPulse pulse={pulse} style={styles.skeletonIcon} />
<SkeletonPulse pulse={pulse} style={styles.skeletonTitle} />
</View>
<SkeletonPulse pulse={pulse} style={styles.skeletonSwitch} />
</View>
))}
</View>
);
}
const styles = StyleSheet.create((theme) => ({
skeletonContent: {
flex: 1,
flexDirection: "row",
alignItems: "center",
gap: theme.spacing[3],
},
skeletonIcon: {
width: 16,
height: 16,
borderRadius: theme.borderRadius.md,
backgroundColor: theme.colors.surface2,
},
skeletonTitle: {
width: 160,
height: 12,
borderRadius: theme.borderRadius.sm,
backgroundColor: theme.colors.surface2,
},
skeletonSwitch: {
width: 36,
height: 20,
borderRadius: theme.borderRadius.full,
backgroundColor: theme.colors.surface2,
},
}));
@@ -0,0 +1,444 @@
import { Plus, Trash2 } from "lucide-react-native";
import { useCallback, useEffect, useMemo, useRef, useState } from "react";
import { useTranslation } from "react-i18next";
import { Text, View } from "react-native";
import { StyleSheet, withUnistyles } from "react-native-unistyles";
import type { AgentModelDefinition, AgentProvider } from "@getpaseo/protocol/agent-types";
import type { ProviderProfileModel } from "@getpaseo/protocol/provider-config";
import { compareMatchScores, scoreTextFields } from "@getpaseo/protocol/search/text-match";
import {
AdaptiveModalSheet,
AdaptiveTextInput,
type SheetHeader,
} from "@/components/adaptive-modal-sheet";
import { SettingsSection } from "@/components/settings";
import { Button } from "@/components/ui/button";
import { ToolbarButton, paneContentToolbarIconSize } from "@/components/ui/pane-content-toolbar";
import { SearchField } from "@/components/ui/search-field";
import { useIsCompactFormFactor } from "@/constants/layout";
import { isWeb } from "@/constants/platform";
import { useDaemonConfig } from "@/hooks/use-daemon-config";
import { CODE_SURFACE_DATASET } from "@/styles/code-surface";
import { settingsStyles } from "@/styles/settings";
import type { Theme } from "@/styles/theme";
import {
resolveProviderDiscoveredModels,
type ProviderDiscoveredModelsCache,
} from "./discovered-models";
import type { ProviderEntry } from "./provider-config";
const ThemedTrash = withUnistyles(Trash2);
const destructiveColorMapping = (theme: Theme) => ({ color: theme.colors.destructive });
const ThemedTextInput = withUnistyles(AdaptiveTextInput, (theme: Theme) => ({
placeholderTextColor: theme.colors.foregroundMuted,
}));
function rankModels<T>(items: T[], query: string, fields: (item: T) => string[]): T[] {
if (!query) return items;
const scored = items
.map((item) => ({ item, score: scoreTextFields(query, fields(item)) }))
.filter(
(entry): entry is { item: T; score: NonNullable<typeof entry.score> } => entry.score !== null,
);
scored.sort((a, b) => compareMatchScores(a.score, b.score));
return scored.map((entry) => entry.item);
}
/**
* A provider's models: search, the ones it reports, and the ones added by hand. The caller decides
* whether it appears and whether the provider's own models are listed.
*/
export function ProviderModels({
serverId,
entry,
discovered,
refresh,
}: {
serverId: string;
entry: ProviderEntry;
/** List the models the provider reports, with search. Only a running provider reports them. */
discovered: boolean;
refresh: (providers?: AgentProvider[]) => Promise<void>;
}) {
const { t } = useTranslation();
const provider = entry.provider;
const { config, patchConfig } = useDaemonConfig(serverId);
const [query, setQuery] = useState("");
const [addSheetOpen, setAddSheetOpen] = useState(false);
const [deletingModelId, setDeletingModelId] = useState<string | null>(null);
const additionalModels = useMemo(
() => config?.providers?.[provider]?.additionalModels ?? [],
[config?.providers, provider],
);
const loading = entry.status === "loading";
// A refresh briefly empties the snapshot's models; keep the last list on screen meanwhile.
const discoveredCacheRef = useRef<ProviderDiscoveredModelsCache | null>(null);
const { models: discoveredModels, cache } = resolveProviderDiscoveredModels({
serverId,
provider,
currentModels: entry.models,
providerSnapshotRefreshing: loading,
previousCache: discoveredCacheRef.current,
});
discoveredCacheRef.current = cache;
// Search shows only beside the provider's own models; a query typed then must not hide custom ones.
const q = discovered ? query.trim() : "";
const filteredDiscovered = useMemo(
() => rankModels(discoveredModels, q, (m) => [m.label, m.id, m.description ?? ""]),
[discoveredModels, q],
);
const filteredCustom = useMemo(
() => rankModels(additionalModels, q, (m) => [m.label, m.id]),
[additionalModels, q],
);
const handleOpenAddSheet = useCallback(() => setAddSheetOpen(true), []);
const handleCloseAddSheet = useCallback(() => setAddSheetOpen(false), []);
const handleDeleteCustom = useCallback(
(modelId: string) => {
setDeletingModelId(modelId);
void patchConfig({
providers: {
[provider]: {
additionalModels: additionalModels.filter((model) => model.id !== modelId),
},
},
})
.then(() => refresh([provider]))
.finally(() => {
setDeletingModelId((current) => (current === modelId ? null : current));
});
},
[additionalModels, patchConfig, provider, refresh],
);
const customTrailing = useMemo(
() => (
<View style={styles.headerTrailing}>
{additionalModels.length > 0 ? (
<Text style={settingsStyles.sectionHeaderTitle}>{additionalModels.length}</Text>
) : null}
<Button
variant="ghost"
leftIcon={Plus}
onPress={handleOpenAddSheet}
accessibilityLabel={t("settings.providers.models.addModel")}
testID="provider-add-model"
/>
</View>
),
[additionalModels.length, handleOpenAddSheet, t],
);
const discoveredTrailing = useMemo(
() =>
discoveredModels.length > 0 ? (
<Text style={settingsStyles.sectionHeaderTitle}>{discoveredModels.length}</Text>
) : null,
[discoveredModels.length],
);
let discoveredBody: React.ReactNode;
if (discoveredModels.length === 0) {
discoveredBody = (
<MutedRow>
{loading
? t("settings.providers.models.loading")
: t("settings.providers.models.noneDetected")}
</MutedRow>
);
} else if (filteredDiscovered.length === 0) {
discoveredBody = <MutedRow>{t("settings.providers.models.noSearchMatches")}</MutedRow>;
} else {
discoveredBody = filteredDiscovered.map((model, index) => (
<DiscoveredModelRow key={model.id} model={model} first={index === 0} />
));
}
let customBody: React.ReactNode;
if (additionalModels.length === 0) {
customBody = <MutedRow>{t("settings.providers.models.noCustom")}</MutedRow>;
} else if (filteredCustom.length === 0) {
customBody = <MutedRow>{t("settings.providers.models.noSearchMatches")}</MutedRow>;
} else {
customBody = filteredCustom.map((model, index) => (
<CustomModelRow
key={model.id}
model={model}
first={index === 0}
deleting={deletingModelId === model.id}
onDelete={handleDeleteCustom}
/>
));
}
return (
<View testID="provider-models">
{discovered ? (
<>
<View style={styles.searchRail}>
<SearchField
value={query}
onChangeText={setQuery}
placeholder={t("settings.providers.models.searchPlaceholder")}
clearAccessibilityLabel={t("sessions.actions.clearSearch")}
testID="provider-settings-search"
/>
</View>
<SettingsSection
title={t("settings.providers.models.discovered")}
trailing={discoveredTrailing}
>
<View style={settingsStyles.card}>{discoveredBody}</View>
</SettingsSection>
</>
) : null}
<SettingsSection title={t("settings.providers.models.custom")} trailing={customTrailing}>
<View style={settingsStyles.card}>{customBody}</View>
</SettingsSection>
<AddCustomModelSheet
serverId={serverId}
provider={provider}
additionalModels={additionalModels}
visible={addSheetOpen}
onClose={handleCloseAddSheet}
refresh={refresh}
/>
</View>
);
}
function MutedRow({ children }: { children: string }) {
return (
<View style={styles.modelRow}>
<Text style={settingsStyles.sectionHeaderTitle}>{children}</Text>
</View>
);
}
function DiscoveredModelRow({ model, first }: { model: AgentModelDefinition; first: boolean }) {
return (
<View style={[styles.modelRow, !first && settingsStyles.rowBorder]}>
<Text style={styles.modelTitle} numberOfLines={1}>
{model.label}
</Text>
<Text style={styles.monoHint} numberOfLines={1} selectable dataSet={CODE_SURFACE_DATASET}>
{model.id}
</Text>
{model.description ? (
<Text style={styles.descriptionInline} numberOfLines={1}>
{model.description}
</Text>
) : null}
</View>
);
}
function CustomModelRow({
model,
first,
deleting,
onDelete,
}: {
model: ProviderProfileModel;
first: boolean;
deleting: boolean;
onDelete: (modelId: string) => void;
}) {
const { t } = useTranslation();
const compact = useIsCompactFormFactor();
const handleDelete = useCallback(() => onDelete(model.id), [model.id, onDelete]);
return (
<View style={[styles.modelRow, !first && settingsStyles.rowBorder]}>
<Text style={[styles.modelTitle, styles.customModelText]} numberOfLines={1}>
{model.label}
</Text>
<Text
style={[styles.monoHint, styles.customModelText]}
numberOfLines={1}
selectable
dataSet={CODE_SURFACE_DATASET}
>
{model.id}
</Text>
<View style={styles.modelRowFiller} />
<ToolbarButton
label={t("settings.providers.models.removeModel", { id: model.id })}
onPress={handleDelete}
disabled={deleting}
compact={compact}
>
<ThemedTrash
size={paneContentToolbarIconSize(compact)}
uniProps={destructiveColorMapping}
/>
</ToolbarButton>
</View>
);
}
function AddCustomModelSheet({
serverId,
provider,
additionalModels,
visible,
onClose,
refresh,
}: {
serverId: string;
provider: string;
additionalModels: ProviderProfileModel[];
visible: boolean;
onClose: () => void;
refresh: (providers?: AgentProvider[]) => Promise<void>;
}) {
const { t } = useTranslation();
const { patchConfig } = useDaemonConfig(serverId);
const [input, setInput] = useState("");
const [error, setError] = useState<string | null>(null);
const [saving, setSaving] = useState(false);
const trimmed = input.trim();
const canAdd = trimmed.length > 0 && !additionalModels.some((model) => model.id === trimmed);
useEffect(() => {
if (!visible) {
setInput("");
setError(null);
}
}, [visible]);
const handleAdd = useCallback(() => {
if (!canAdd) return;
setError(null);
setSaving(true);
void patchConfig({
providers: {
[provider]: {
additionalModels: [...additionalModels, { id: trimmed, label: trimmed }],
},
},
})
.then(() => refresh([provider]))
.then(() => onClose())
.catch((err: unknown) => {
setError(err instanceof Error ? err.message : t("settings.providers.models.failedToSave"));
})
.finally(() => setSaving(false));
}, [additionalModels, canAdd, onClose, patchConfig, provider, refresh, t, trimmed]);
const header = useMemo<SheetHeader>(
() => ({ title: t("settings.providers.models.addCustomTitle") }),
[t],
);
return (
<AdaptiveModalSheet
header={header}
visible={visible}
onClose={onClose}
desktopMaxWidth={420}
snapPoints={ADD_SNAP_POINTS}
testID="add-custom-model-sheet"
>
<View style={styles.formGroup}>
<Text style={styles.formLabel}>{t("settings.providers.models.modelId")}</Text>
<ThemedTextInput
initialValue={input}
resetKey={`add-custom-${visible}`}
onChangeText={setInput}
onSubmitEditing={handleAdd}
placeholder={t("settings.providers.models.modelIdPlaceholder")}
autoCapitalize="none"
autoCorrect={false}
returnKeyType="done"
// @ts-expect-error - outlineStyle is web-only
style={[styles.formInput, isWeb && { outlineStyle: "none" }]}
/>
{error ? <Text style={styles.errorText}>{error}</Text> : null}
<View style={styles.formActions}>
<Button variant="secondary" onPress={onClose} disabled={saving}>
{t("common.actions.cancel")}
</Button>
<Button variant="default" onPress={handleAdd} disabled={!canAdd} loading={saving}>
{saving ? t("settings.providers.models.adding") : t("settings.providers.models.add")}
</Button>
</View>
</View>
</AdaptiveModalSheet>
);
}
const ADD_SNAP_POINTS = ["40%"];
const styles = StyleSheet.create((theme) => ({
searchRail: {
flexDirection: "row",
marginBottom: theme.spacing[3],
},
headerTrailing: {
flexDirection: "row",
alignItems: "center",
gap: theme.spacing[1],
},
modelRow: {
flexDirection: "row",
alignItems: "center",
paddingVertical: theme.spacing[2],
paddingHorizontal: theme.spacing[4],
gap: theme.spacing[3],
},
modelTitle: {
color: theme.colors.foreground,
fontSize: theme.fontSize.base,
flexShrink: 0,
},
monoHint: {
fontFamily: theme.fontFamily.mono,
fontSize: theme.fontSize.code,
color: theme.colors.foregroundMuted,
flexShrink: 0,
},
descriptionInline: {
flex: 1,
fontSize: theme.fontSize.sm,
color: theme.colors.foregroundMuted,
},
customModelText: {
flexShrink: 1,
minWidth: 0,
},
modelRowFiller: {
flex: 1,
},
formGroup: {
gap: theme.spacing[3],
},
formLabel: {
fontSize: theme.fontSize.base,
fontWeight: theme.fontWeight.medium,
color: theme.colors.foreground,
},
formInput: {
backgroundColor: theme.colors.surface2,
borderRadius: theme.borderRadius.lg,
paddingHorizontal: theme.spacing[4],
paddingVertical: theme.spacing[3],
color: theme.colors.foreground,
borderWidth: 1,
borderColor: theme.colors.border,
fontSize: theme.fontSize.base,
},
errorText: {
fontSize: theme.fontSize.sm,
color: theme.colors.destructive,
},
formActions: {
flexDirection: "row",
justifyContent: "flex-end",
gap: theme.spacing[2],
},
}));
@@ -0,0 +1,23 @@
import { Text, View } from "react-native";
import { StyleSheet } from "react-native-unistyles";
import { settingsStyles } from "@/styles/settings";
/** A card holding one muted line, where a provider list or page has nothing to show yet. */
export function ProviderNotice({ message, testID }: { message: string; testID?: string }) {
return (
<View style={[settingsStyles.card, styles.card]} testID={testID}>
<Text style={styles.text}>{message}</Text>
</View>
);
}
const styles = StyleSheet.create((theme) => ({
card: {
padding: theme.spacing[4],
alignItems: "center",
},
text: {
color: theme.colors.foregroundMuted,
fontSize: theme.fontSize.base,
},
}));
@@ -0,0 +1,178 @@
import React, { act } from "react";
import { createRoot, type Root } from "react-dom/client";
import { within } from "@testing-library/dom";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { Text } from "react-native";
import { i18n as testI18n } from "@/i18n/i18next";
import { ProviderRow } from "./provider-row";
import type { RowSummary } from "./row-summary";
// Load translations so rows expose their real accessible names and copy.
void testI18n;
// App sources compile against the classic JSX runtime, which expects React on the global.
beforeEach(() => vi.stubGlobal("React", React));
const mounted: { root: Root; container: HTMLDivElement }[] = [];
afterEach(() => {
for (const entry of mounted.splice(0)) {
act(() => entry.root.unmount());
entry.container.remove();
}
});
const ICON = <Text testID="provider-icon">*</Text>;
function mount(summary: RowSummary, options: { enabled?: boolean; label?: string } = {}) {
const onOpen = vi.fn();
const onToggle = vi.fn();
const label = options.label ?? "Claude";
const container = document.createElement("div");
document.body.appendChild(container);
const root = createRoot(container);
act(() =>
root.render(
<ProviderRow
provider="claude"
label={label}
icon={ICON}
summary={summary}
enabled={options.enabled ?? true}
toggling={false}
onOpen={onOpen}
onToggle={onToggle}
/>,
),
);
mounted.push({ root, container });
const view = within(container);
return {
view,
onOpen,
onToggle,
row: () => view.getByTestId("provider-row-claude"),
opener: () => view.getByRole("button", { name: `${label} provider details` }),
toggle: () => view.queryByRole("switch", { name: `Enable ${label}` }),
};
}
function pressEnter(target: HTMLElement) {
target.focus();
for (const type of ["keydown", "keyup"]) {
target.dispatchEvent(
new KeyboardEvent(type, { key: "Enter", bubbles: true, cancelable: true }),
);
}
}
function textOrder(row: HTMLElement, texts: string[]): number[] {
const content = row.textContent ?? "";
return texts.map((text) => content.indexOf(text));
}
describe("provider row", () => {
it("names the provider with its label and says Disabled when it is off", () => {
const row = mount({ kind: "disabled" }, { enabled: false, label: "Codex" });
expect(row.row().textContent).toContain("Codex");
expect(row.view.getByText("Disabled")).toBeTruthy();
expect(row.toggle()?.getAttribute("aria-checked")).toBe("false");
});
it("composes the row as icon, label, version and models, then switch", () => {
const row = mount({ kind: "ready", version: "2.1.321", models: 3 });
const element = row.row();
expect(row.view.getByText("2.1.321 · 3 models")).toBeTruthy();
const [icon, label, summary] = textOrder(element, ["*", "Claude", "2.1.321 · 3 models"]);
expect(icon).toBeLessThan(label);
expect(label).toBeLessThan(summary);
const toggle = row.toggle();
expect(toggle).not.toBeNull();
expect(
row.view.getByText("2.1.321 · 3 models").compareDocumentPosition(toggle as Node) &
Node.DOCUMENT_POSITION_FOLLOWING,
).toBeTruthy();
});
it("asks its host to open the provider when the row is pressed", () => {
const row = mount({ kind: "disabled" }, { enabled: false });
act(() => row.opener().click());
expect(row.onOpen).toHaveBeenCalledWith("claude");
});
it("keeps the switch out of the row's button, so Enter on the switch only toggles", () => {
const row = mount({ kind: "ready", version: null, models: 3 });
const toggle = row.toggle() as HTMLElement;
expect(row.opener().contains(toggle)).toBe(false);
// Dispatched in one act, so the test ends before the Switch's animation runs a frame.
act(() => pressEnter(toggle));
expect(row.onToggle).toHaveBeenCalledWith("claude", false);
expect(row.onOpen).not.toHaveBeenCalled();
});
it("toggles the provider from the switch without opening it", () => {
const row = mount({ kind: "ready", version: null, models: 3 });
act(() => row.toggle()?.click());
expect(row.onToggle).toHaveBeenCalledWith("claude", false);
expect(row.onOpen).not.toHaveBeenCalled();
});
it("leaves the state line readable to screen readers, and the name to the row's button", () => {
const row = mount({ kind: "failing", message: "opencode exited with code 1" });
expect(row.view.getByText("opencode exited with code 1").closest("[aria-hidden]")).toBeNull();
expect(row.view.getByText("Claude").closest("[aria-hidden]")).not.toBeNull();
});
it("says an update is available after the version", () => {
const row = mount({ kind: "updateAvailable", version: "2.1.321" });
expect(row.view.getByText("2.1.321 · Update available")).toBeTruthy();
});
it("names the target while an update runs, or says Updating... without one", () => {
expect(
mount({ kind: "updating", target: "1.0.31" }).view.getByText("Updating to 1.0.31..."),
).toBeTruthy();
expect(mount({ kind: "updating", target: null }).view.getByText("Updating...")).toBeTruthy();
});
it("shows the error in the hint", () => {
const row = mount({ kind: "failing", message: "opencode exited with code 1" });
expect(row.view.getByText("opencode exited with code 1")).toBeTruthy();
expect(row.toggle()).not.toBeNull();
});
it("offers no switch on a provider that is not installed", () => {
const row = mount({ kind: "notInstalled" });
expect(row.view.getByText("Not installed")).toBeTruthy();
expect(row.toggle()).toBeNull();
act(() => row.opener().click());
expect(row.onOpen).toHaveBeenCalledWith("claude");
});
it("keeps the row as tall while its line loads as once it has arrived", () => {
const pending = mount({ kind: "pending" }).row().getBoundingClientRect().height;
const ready = mount({ kind: "ready", version: "2.1.321", models: 3 })
.row()
.getBoundingClientRect().height;
const updating = mount({ kind: "updating", target: "1.0.31" })
.row()
.getBoundingClientRect().height;
const failing = mount({ kind: "failing", message: "boom" })
.row()
.getBoundingClientRect().height;
expect(pending).toBe(ready);
expect(updating).toBe(ready);
expect(failing).toBe(ready);
});
it("keeps a long, multi-line error to the row's one line", () => {
const ready = mount({ kind: "ready", version: "2.1.321", models: 3 })
.row()
.getBoundingClientRect().height;
const message = [
"ACP agent process exited before initialization completed (exit code 1)",
"broken-acp: exited with code 1",
].join("\n");
const failing = mount({ kind: "failing", message }).row().getBoundingClientRect().height;
expect(failing).toBe(ready);
});
});
@@ -0,0 +1,110 @@
import type { TFunction } from "i18next";
import { useCallback, useMemo, type ReactNode } from "react";
import { useTranslation } from "react-i18next";
import { SettingsDetailRow, type SettingsRowHintStatus } from "@/components/settings";
import { Switch } from "@/components/ui/switch";
import { rowHasSwitch, type RowSummary } from "./row-summary";
export interface ProviderRowProps {
provider: string;
label: string;
icon: ReactNode;
summary: RowSummary;
enabled: boolean;
/** The Enabled switch is being saved. */
toggling: boolean;
onOpen: (provider: string) => void;
onToggle: (provider: string, enabled: boolean) => void;
}
/**
* One provider in the list: its icon and name, a line saying how it is, the Enabled switch when
* there is something to switch, and the chevron to its detail.
*/
export function ProviderRow({
provider,
label,
icon,
summary,
enabled,
toggling,
onOpen,
onToggle,
}: ProviderRowProps) {
const { t } = useTranslation();
const handleOpen = useCallback(() => onOpen(provider), [onOpen, provider]);
const handleToggle = useCallback(
(value: boolean) => onToggle(provider, value),
[onToggle, provider],
);
const hint = describeRowSummary(summary, t);
const hasSwitch = rowHasSwitch(summary);
const toggle = useMemo(
() =>
hasSwitch ? (
<Switch
value={enabled}
onValueChange={handleToggle}
disabled={toggling}
accessibilityLabel={t("settings.providers.enableProvider", { name: label })}
/>
) : null,
[enabled, handleToggle, hasSwitch, label, t, toggling],
);
return (
<SettingsDetailRow
leading={icon}
label={label}
hint={hint.text}
hintStatus={hint.status}
control={toggle}
accessibilityLabel={t("settings.providers.providerDetails", { name: label })}
onPress={handleOpen}
testID={`provider-row-${provider}`}
/>
);
}
function describeRowSummary(
summary: RowSummary,
t: TFunction,
): { text: string | undefined; status: SettingsRowHintStatus | undefined } {
switch (summary.kind) {
case "pending":
return { text: undefined, status: "pending" };
case "ready": {
const models =
summary.models === 1
? t("settings.providers.models.one")
: t("settings.providers.models.many", { count: summary.models });
const parts = [summary.version, summary.models > 0 ? models : null].filter(Boolean);
return {
text: parts.length ? parts.join(" · ") : t("settings.providers.statuses.available"),
status: undefined,
};
}
case "updateAvailable":
return {
text: [summary.version, t("settings.providers.installation.updateAvailable")]
.filter(Boolean)
.join(" · "),
status: undefined,
};
case "updating":
return {
text: summary.target
? t("settings.providers.list.updatingTo", { version: summary.target })
: t("settings.providers.installation.updating"),
status: "busy",
};
case "failing":
return {
text: summary.message ?? t("settings.providers.diagnostic.unknownError"),
status: "error",
};
case "notInstalled":
return { text: t("settings.providers.statuses.notInstalled"), status: undefined };
case "disabled":
return { text: t("settings.providers.statuses.disabled"), status: undefined };
}
}
@@ -0,0 +1,191 @@
import { describe, expect, it } from "vitest";
import type { ProviderInstallationUpdate } from "@getpaseo/protocol/messages";
import type { ProviderSnapshotEntry } from "@getpaseo/protocol/agent-types";
import type { ProviderInstallationRead } from "@/components/provider-installation";
import { readRowSummary } from "./row-summary";
type Read = Pick<ProviderInstallationRead, "state" | "updates" | "action">;
function entry(overrides: Partial<ProviderSnapshotEntry> = {}): ProviderSnapshotEntry {
return {
provider: "claude",
label: "Claude",
status: "ready",
enabled: true,
modes: [],
models: [
{ provider: "claude", id: "opus", label: "Opus" },
{ provider: "claude", id: "sonnet", label: "Sonnet" },
],
...overrides,
};
}
function installed(version: string | undefined, overrides: Partial<Read> = {}): Read {
return {
state: {
status: "ready",
installation: { inspection: { status: "installed", version }, canUpdate: true },
},
updates: { status: "ready", updateCheck: { status: "current" } },
action: { current: null, starting: false, startError: null, start: () => undefined },
...overrides,
};
}
function update(operation: ProviderInstallationUpdate["operation"]): ProviderInstallationUpdate {
return { operation, output: [] };
}
const oldHost: Read = {
state: { status: "unsupported" },
updates: { status: "hidden" },
action: undefined,
};
describe("provider row summary", () => {
it("reads version and model count for a provider that runs", () => {
expect(readRowSummary(entry(), installed("2.1.321"))).toEqual({
kind: "ready",
version: "2.1.321",
models: 2,
});
});
it("says an update is available after the version", () => {
const read = installed("2.1.321", {
updates: { status: "ready", updateCheck: { status: "available", versions: ["2.1.400"] } },
});
expect(readRowSummary(entry(), read)).toEqual({ kind: "updateAvailable", version: "2.1.321" });
});
it("names the target version while an update runs, when the check reported one", () => {
const running = update({ status: "running", id: "u1", startedAt: "2026-11-14T10:00:00Z" });
const one = installed("1.0.30", {
updates: { status: "ready", updateCheck: { status: "available", versions: ["1.0.31"] } },
action: { current: running, starting: false, startError: null, start: () => undefined },
});
expect(readRowSummary(entry(), one)).toEqual({ kind: "updating", target: "1.0.31" });
const unknown = installed("1.0.30", {
updates: { status: "ready", updateCheck: { status: "available" } },
action: { current: null, starting: true, startError: null, start: () => undefined },
});
expect(readRowSummary(entry(), unknown)).toEqual({ kind: "updating", target: null });
});
it("reports a failed update as the fault", () => {
const failed = update({
status: "failed",
id: "u1",
startedAt: "2026-11-14T10:00:00Z",
finishedAt: "2026-11-14T10:01:00Z",
message: "npm exited with code 1",
});
const read = installed("1.0.30", {
action: { current: failed, starting: false, startError: null, start: () => undefined },
});
expect(readRowSummary(entry(), read)).toEqual({
kind: "failing",
message: "npm exited with code 1",
});
});
it("reads the provider's own state once Refresh drops a failed update", () => {
const failed = update({
status: "failed",
id: "u1",
startedAt: "2026-11-14T10:00:00Z",
finishedAt: "2026-11-14T10:01:00Z",
message: "npm exited with code 1",
});
const stillFailed = { current: failed, starting: false, startError: null, start: () => {} };
// A fresh inspection alone leaves the failure: reopening without Refresh still shows it.
expect(readRowSummary(entry(), installed("2.1.400", { action: stillFailed }))).toEqual({
kind: "failing",
message: "npm exited with code 1",
});
// Refresh drops the failed update, so the row has no current update to report.
const cleared = { current: null, starting: false, startError: null, start: () => {} };
expect(readRowSummary(entry(), installed("2.1.400", { action: cleared }))).toEqual({
kind: "ready",
version: "2.1.400",
models: 2,
});
const pending = installed("2.1.321", {
updates: { status: "ready", updateCheck: { status: "available", versions: ["2.1.400"] } },
action: cleared,
});
expect(readRowSummary(entry(), pending)).toEqual({
kind: "updateAvailable",
version: "2.1.321",
});
});
it("reports the provider's error", () => {
expect(
readRowSummary(entry({ status: "error", error: " opencode exited with code 1 " }), oldHost),
).toEqual({ kind: "failing", message: "opencode exited with code 1" });
expect(readRowSummary(entry({ status: "error" }), oldHost)).toEqual({
kind: "failing",
message: null,
});
});
it("calls a missing CLI Not installed, not a fault", () => {
expect(readRowSummary(entry({ status: "unavailable" }), oldHost)).toEqual({
kind: "notInstalled",
});
const missing: Read = {
...oldHost,
state: { status: "ready", installation: { inspection: { status: "not_installed" } } },
};
expect(readRowSummary(entry({ status: "error", error: "spawn ENOENT" }), missing)).toEqual({
kind: "notInstalled",
});
});
it("says Disabled for a provider that is off", () => {
expect(readRowSummary(entry({ enabled: false }), installed("2.1.321"))).toEqual({
kind: "disabled",
});
});
it("calls a disabled provider whose CLI is missing Not installed, so turning it on changes nothing", () => {
const missing: Read = {
...oldHost,
state: { status: "ready", installation: { inspection: { status: "not_installed" } } },
};
expect(readRowSummary(entry({ enabled: false, status: "unavailable" }), missing)).toEqual({
kind: "notInstalled",
});
// A disabled provider is never probed, so without an inspection it is only Disabled.
expect(readRowSummary(entry({ enabled: false, status: "unavailable" }), oldHost)).toEqual({
kind: "disabled",
});
});
it("holds the line until the installation is read", () => {
const reading: Read = { ...oldHost, state: { status: "loading" } };
expect(readRowSummary(entry(), reading)).toEqual({ kind: "pending" });
});
it("holds the line while the provider's first probe runs", () => {
expect(readRowSummary(entry({ status: "loading", models: [] }), oldHost)).toEqual({
kind: "pending",
});
});
it("keeps the last count while the provider is probed again", () => {
expect(readRowSummary(entry({ status: "loading" }), installed("2.1.321"))).toEqual({
kind: "ready",
version: "2.1.321",
models: 2,
});
});
it("reads a count alone on hosts that cannot report installations", () => {
expect(readRowSummary(entry(), oldHost)).toEqual({ kind: "ready", version: null, models: 2 });
});
});
@@ -0,0 +1,69 @@
import type { ProviderInstallationRead } from "@/components/provider-installation";
import { filterSelectableModels } from "@/provider-selection/model-catalog";
import type { ProviderEntry } from "./provider-config";
/** What a provider's list row says under its name. */
export type RowSummary =
/** Not known yet; the row holds the line's space. */
| { kind: "pending" }
| { kind: "ready"; version: string | null; models: number }
| { kind: "updateAvailable"; version: string | null }
| { kind: "updating"; target: string | null }
/** The provider or its last update failed. A null message has no detail to show. */
| { kind: "failing"; message: string | null }
| { kind: "notInstalled" }
| { kind: "disabled" };
type InstallationFacts = Pick<ProviderInstallationRead, "state" | "updates" | "action">;
/**
* One line per provider, from the snapshot and the installation read. A running update leads
* because the user just started it; then whatever keeps the provider from running, where a missing
* CLI is not a fault; then the version and update state once the host has answered.
*/
export function readRowSummary(entry: ProviderEntry, facts: InstallationFacts): RowSummary {
return readRunningUpdate(facts) ?? readBlocker(entry, facts) ?? readSettled(entry, facts);
}
function readRunningUpdate({ updates, action }: InstallationFacts): RowSummary | null {
if (!action || !(action.starting || action.current?.operation.status === "running")) return null;
const updateCheck = updates.status === "ready" ? updates.updateCheck : null;
const versions = updateCheck?.status === "available" ? updateCheck.versions : undefined;
return { kind: "updating", target: versions?.length === 1 ? versions[0] : null };
}
function readBlocker(
entry: ProviderEntry,
{ state, action }: InstallationFacts,
): RowSummary | null {
// A missing CLI wins over Disabled, so the row offers no switch that turning on would take away.
// Without an inspection a disabled provider is only Disabled: the host never probes it.
const inspection = state.status === "ready" ? state.installation?.inspection : undefined;
if (inspection?.status === "not_installed") return { kind: "notInstalled" };
if (!entry.enabled) return { kind: "disabled" };
if (entry.status === "unavailable") return { kind: "notInstalled" };
if (entry.status === "error") return { kind: "failing", message: entry.error?.trim() || null };
const operation = action?.current?.operation;
if (operation?.status === "failed") {
return { kind: "failing", message: operation.message.trim() || null };
}
return null;
}
function readSettled(entry: ProviderEntry, { state, updates }: InstallationFacts): RowSummary {
const models = filterSelectableModels(entry.models ?? null)?.length ?? 0;
// The last count stays while the provider is probed again; only a first probe holds the line.
if (state.status === "loading" || (entry.status === "loading" && models === 0)) {
return { kind: "pending" };
}
const inspection = state.status === "ready" ? state.installation?.inspection : undefined;
const version = inspection?.status === "installed" ? (inspection.version ?? null) : null;
const updateCheck = updates.status === "ready" ? updates.updateCheck : null;
if (updateCheck?.status === "available") return { kind: "updateAvailable", version };
return { kind: "ready", version, models };
}
/** A provider that is not installed has nothing to switch: the picker leaves it out already. */
export function rowHasSwitch(summary: RowSummary): boolean {
return summary.kind !== "notInstalled";
}
@@ -0,0 +1,15 @@
import type { DimensionValue } from "react-native";
/**
* Where a provider sheet sits, decided by the surface that opens it. Setup passes its own card's
* size so the sheet covers the card exactly and reads as a page of setup.
*/
export interface ProviderSheetFrame {
desktopMaxWidth?: number;
desktopHeight?: DimensionValue;
snapPoints?: string[];
/** A back arrow replaces the close button: the sheet stands in for a page of the surface below. */
returns?: boolean;
}
export const OVERLAY_SHEET_FRAME: ProviderSheetFrame = { snapPoints: ["65%", "92%"] };
@@ -1008,7 +1008,9 @@ export function openScheduleForm(snapshot: ScheduleFormSnapshot): ScheduleFormMo
}
publish({
...resolved,
modelSelectorProviders: buildSelectableProviderSelectorProviders(providerEntries),
modelSelectorProviders: buildSelectableProviderSelectorProviders(providerEntries, {
selectedProvider: resolved.selectedProvider,
}),
providerResolutionByServerId,
providerSnapshotRequest: isPendingResolution ? null : state.providerSnapshotRequest,
});
@@ -5,7 +5,7 @@ import { Pressable, Text, View } from "react-native";
import { useFocusEffect } from "expo-router/react-navigation";
import { StyleSheet } from "react-native-unistyles";
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { ArrowLeft, MoreVertical, Pencil, Plus } from "lucide-react-native";
import { MoreVertical, Pencil, Plus } from "lucide-react-native";
import { ProjectIconView } from "@/components/project-icon-view";
import type {
PaseoConfigRaw,
@@ -29,6 +29,7 @@ import { EditingTextInput as TextInput } from "@/components/ui/text-input";
import { SettingsTextAreaCard } from "@/components/settings-textarea";
import { SettingsGroup } from "@/components/settings/headings/settings-group";
import { SettingsSection } from "@/components/settings/headings/settings-section";
import { SettingsBackLink, SettingsDetailHeader } from "@/components/settings";
import { settingsStyles } from "@/styles/settings";
import { useProjects } from "@/hooks/use-projects";
import type { ProjectEditFormSnapshot } from "@/projects/edit-form";
@@ -170,16 +171,11 @@ function NoEditableTarget({
function BackToProjectsButton({ onPress }: { onPress: () => void }) {
const { t } = useTranslation();
return (
<Button
testID="project-settings-back-link"
accessibilityLabel={t("settings.project.backToProjects")}
<SettingsBackLink
label={t("settings.project.backToProjects")}
onPress={onPress}
variant="ghost"
leftIcon={ArrowLeft}
style={styles.backButton}
>
{t("settings.project.backToProjects")}
</Button>
testID="project-settings-back-link"
/>
);
}
@@ -260,33 +256,51 @@ function ProjectSettingsBody({
const handleReload = useCallback(() => {
void readQuery.refetch();
}, [readQuery]);
const backLink = useMemo(
() =>
showBackToProjects
? {
label: t("settings.project.backToProjects"),
onPress: onBackToProjects,
testID: "project-settings-back-link",
}
: undefined,
[onBackToProjects, showBackToProjects, t],
);
const titleIcon = useMemo(
() => (
<ProjectTitleIcon
iconDataUri={projectIconDataUri}
projectName={selectedHost.projectName}
projectViewKey={project.viewKey}
/>
),
[project.viewKey, projectIconDataUri, selectedHost.projectName],
);
const editButton = useMemo(
() => (
<Pressable
testID="project-edit-button"
accessibilityRole="button"
accessibilityLabel={t("settings.project.edit.title")}
onPress={openEditSheet}
hitSlop={8}
style={styles.editButton}
>
<Pencil size={ICON_SIZE} color={styles.iconColor.color} />
</Pressable>
),
[openEditSheet, t],
);
return (
<View role="main" style={styles.body}>
{showBackToProjects ? <BackToProjectsButton onPress={onBackToProjects} /> : null}
<View style={styles.headerBlock}>
<View style={styles.titleRow}>
<ProjectTitleIcon
iconDataUri={projectIconDataUri}
projectName={selectedHost.projectName}
projectViewKey={project.viewKey}
/>
<Text style={styles.projectTitle} numberOfLines={1}>
{selectedHost.projectName}
</Text>
<Pressable
testID="project-edit-button"
accessibilityRole="button"
accessibilityLabel={t("settings.project.edit.title")}
onPress={openEditSheet}
hitSlop={8}
style={styles.editButton}
>
<Pencil size={ICON_SIZE} color={styles.iconColor.color} />
</Pressable>
</View>
</View>
<SettingsDetailHeader
back={backLink}
icon={titleIcon}
title={selectedHost.projectName}
trailing={editButton}
/>
<ProjectEditSheet
// A new instance per open seeds the form from the project as it stands now.
@@ -1108,26 +1122,6 @@ const styles = StyleSheet.create((theme) => ({
padding: theme.spacing[4],
gap: theme.spacing[2],
},
backButton: {
alignSelf: "flex-start",
paddingHorizontal: 0,
},
headerBlock: {
marginTop: theme.spacing[2],
marginBottom: theme.spacing[4],
gap: theme.spacing[2],
},
titleRow: {
flexDirection: "row",
alignItems: "center",
gap: theme.spacing[3],
},
projectTitle: {
color: theme.colors.foreground,
fontSize: theme.fontSize.base,
fontWeight: theme.fontWeight.medium,
flexShrink: 1,
},
editButton: {
padding: theme.spacing[1],
},
+21 -3
View File
@@ -118,6 +118,7 @@ import { MetadataGenerationPage } from "@/screens/settings/metadata-generation-p
import { HostVoicePage } from "@/screens/settings/voice/voice-page";
import ProjectsScreen from "@/screens/projects-screen";
import ProjectSettingsScreen from "@/screens/project-settings-screen";
import { ProviderDetailPage } from "@/provider-settings";
import {
SETTINGS_DESKTOP_DETAIL_MIN_WIDTH,
SETTINGS_DESKTOP_SIDEBAR_WIDTH,
@@ -990,6 +991,7 @@ function SettingsSidebar({
let selectedHostSection: HostSectionSlug | null = null;
if (view.kind === "host") selectedHostSection = view.section;
if (view.kind === "project") selectedHostSection = "projects";
if (view.kind === "provider") selectedHostSection = "providers";
if (view.kind === "plugin" || view.kind === "pluginListing") selectedHostSection = "plugins";
const sidebarBody = (
@@ -1137,7 +1139,8 @@ export default function SettingsScreen({ view }: SettingsScreenProps) {
view.kind === "host" ||
view.kind === "project" ||
view.kind === "plugin" ||
view.kind === "pluginListing"
view.kind === "pluginListing" ||
view.kind === "provider"
)
return view.serverId;
return resolveActiveHostServerId({
@@ -1216,8 +1219,12 @@ export default function SettingsScreen({ view }: SettingsScreenProps) {
const handleSelectHost = useCallback(
(serverId: string) => {
selectSettingsHost(serverId);
if (view.kind === "project") {
const target = buildSettingsHostSectionRoute(serverId, "projects");
if (view.kind === "project" || view.kind === "provider") {
// The detail belongs to the old host; open the same list on the new one.
const target = buildSettingsHostSectionRoute(
serverId,
view.kind === "project" ? "projects" : "providers",
);
if (isCompactLayout) {
router.push(target);
} else {
@@ -1296,6 +1303,7 @@ export default function SettingsScreen({ view }: SettingsScreenProps) {
if (view.kind === "project") {
return t("settings.projects");
}
if (view.kind === "provider") return t("settings.hostSections.providers");
return undefined;
})();
@@ -1331,6 +1339,16 @@ export default function SettingsScreen({ view }: SettingsScreenProps) {
/>
);
}
if (view.kind === "provider") {
return (
<ProviderDetailPage
serverId={view.serverId}
provider={view.providerId}
onBack={handleBackFromDetail}
showBack={!isCompactLayout}
/>
);
}
if (view.kind === "section") {
const item = SIDEBAR_SECTION_ITEMS.find((candidate) => candidate.id === view.section);
if (!item || !isSectionAvailable(item, isDesktopApp, hardwareKeyboardPresent)) return null;
@@ -13,7 +13,7 @@ import { DropdownMenu, DropdownMenuContent, DropdownMenuItem } from "@/component
import { DropdownTrigger } from "@/components/ui/dropdown-trigger";
import { SettingsSection } from "@/components/settings/headings/settings-section";
import { ThemePicker } from "@/appearance/theme-picker";
import { Button } from "@/components/ui/button";
import { SegmentedControl } from "@/components/ui/segmented-control";
import { EditingTextInput, type EditingTextInputHandle } from "@/components/ui/text-input";
import {
MAX_CODE_FONT_SIZE,
@@ -23,11 +23,10 @@ import {
MIN_CONTENT_FONT_SIZE,
MIN_UI_BASE_FONT_SIZE,
parseClampedFontSize,
parseContentMaxWidth,
resolveContentMaxWidth,
sanitizeFontFamily,
useAppSettings,
type AppSettings,
type ContentWidthPreset,
} from "@/hooks/use-settings";
import { DEFAULT_MONO_FONT_STACK, DEFAULT_UI_FONT_STACK } from "@/styles/theme";
import { isNative } from "@/constants/platform";
@@ -172,68 +171,35 @@ function FontSizeRow({
}
// ---------------------------------------------------------------------------
// Content width: numeric field (commit on blur/submit) + reset to the default
// ---------------------------------------------------------------------------
interface ContentWidthRowProps {
value: AppSettings["contentMaxWidth"];
onChange: (value: AppSettings["contentMaxWidth"]) => void;
}
function ContentWidthRow({ value, onChange }: ContentWidthRowProps) {
function ContentWidthRow({
value,
onChange,
}: {
value: AppSettings["contentWidth"];
onChange: (value: ContentWidthPreset) => void;
}) {
const { t } = useTranslation();
const width = resolveContentMaxWidth({ contentMaxWidth: value });
// The field is uncontrolled, so a saved or reset width is written into it directly.
const input = useRef<EditingTextInputHandle>(null);
useEffect(() => {
input.current?.replaceText(String(width));
}, [width]);
const commit = useCallback(() => {
const next = parseContentMaxWidth(input.current?.getText()) ?? width;
input.current?.replaceText(String(next));
// Typing the width already in effect keeps following the default.
if (next !== width) {
onChange(next);
}
}, [onChange, width]);
const reset = useCallback(() => {
onChange(null);
}, [onChange]);
return (
<View style={settingsStyles.row}>
<View style={settingsStyles.rowContent}>
<View style={styles.contentWidthRow}>
<View>
<Text style={settingsStyles.rowTitle}>{t("settings.appearance.layout.contentWidth")}</Text>
<Text style={settingsStyles.rowHint}>
{t("settings.appearance.layout.contentWidthHint")}
{typeof value === "number"
? t("settings.appearance.layout.contentWidthCustom", { width: value })
: t("settings.appearance.layout.contentWidthHint")}
</Text>
</View>
<View style={styles.sizeField}>
{value === null ? null : (
<Button
variant="ghost"
onPress={reset}
accessibilityLabel={t("settings.appearance.layout.resetAccessibility")}
>
{t("settings.appearance.layout.reset")}
</Button>
)}
<TextInput
ref={input}
initialValue={String(width)}
onBlur={commit}
onSubmitEditing={commit}
keyboardType="number-pad"
inputMode="numeric"
selectTextOnFocus
style={styles.widthInput}
accessibilityLabel={t("settings.appearance.layout.contentWidthAccessibility")}
/>
<Text style={styles.unit}>px</Text>
</View>
<SegmentedControl<ContentWidthPreset>
testID="content-width-options"
value={typeof value === "number" ? null : value}
onValueChange={onChange}
options={[
{ value: "default", label: t("settings.appearance.layout.contentWidthDefault") },
{ value: "wide", label: t("settings.appearance.layout.contentWidthWide") },
{ value: "full", label: t("settings.appearance.layout.contentWidthFull") },
]}
/>
</View>
);
}
@@ -333,9 +299,9 @@ export function AppearanceSection() {
setCodeSizeDraft(String(settings.codeFontSize));
}, [settings.codeFontSize]);
const handleContentMaxWidthChange = useCallback(
(contentMaxWidth: AppSettings["contentMaxWidth"]) => {
void updateSettings({ contentMaxWidth });
const handleContentWidthChange = useCallback(
(contentWidth: ContentWidthPreset) => {
void updateSettings({ contentWidth });
},
[updateSettings],
);
@@ -504,10 +470,7 @@ export function AppearanceSection() {
</SettingsSection>
<SettingsSection title={t("settings.appearance.layout.title")}>
<View style={settingsStyles.card}>
<ContentWidthRow
value={settings.contentMaxWidth}
onChange={handleContentMaxWidthChange}
/>
<ContentWidthRow value={settings.contentWidth} onChange={handleContentWidthChange} />
</View>
</SettingsSection>
<SettingsSection title={t("settings.appearance.syntax.title")}>
@@ -571,18 +534,10 @@ const styles = StyleSheet.create((theme) => ({
fontSize: theme.fontSize.base,
textAlign: "right",
},
widthInput: {
width: 80,
minHeight: 36,
paddingVertical: theme.spacing[2],
paddingHorizontal: theme.spacing[3],
borderRadius: theme.borderRadius.md,
borderWidth: theme.borderWidth[1],
borderColor: theme.colors.border,
backgroundColor: theme.colors.surface2,
color: theme.colors.foreground,
fontSize: theme.fontSize.base,
textAlign: "right",
contentWidthRow: {
alignItems: "flex-start",
gap: theme.spacing[2],
padding: theme.spacing[4],
},
unit: {
color: theme.colors.foregroundMuted,
@@ -49,7 +49,8 @@ import {
useHostRuntimeSnapshot,
useHosts,
} from "@/runtime/host-runtime";
import { ProvidersSection } from "@/screens/settings/providers-section";
import { ProviderList } from "@/provider-settings";
import { openProviderSettings } from "@/navigation/settings-navigation";
import { HostUsageSection } from "@/usage";
import { HostAppearanceSection } from "@/screens/settings/host-appearance-section";
import { SettingsSection } from "@/components/settings/headings/settings-section";
@@ -334,6 +335,10 @@ export function HostWorkspacesPage({ serverId }: { serverId: string }) {
export function HostProvidersPage({ serverId }: { serverId: string }) {
const host = useHostProfile(serverId);
const openProvider = useCallback(
(providerId: string) => openProviderSettings(serverId, providerId),
[serverId],
);
if (!host) {
return <HostNotFound />;
@@ -341,7 +346,7 @@ export function HostProvidersPage({ serverId }: { serverId: string }) {
return (
<View>
<ProvidersSection serverId={serverId} />
<ProviderList serverId={serverId} onOpenProvider={openProvider} />
</View>
);
}
@@ -19,12 +19,15 @@ export function MetadataGenerationPage({ serverId }: { serverId: string }) {
const { t } = useTranslation();
const { config, isLoading: isConfigLoading, patchConfig } = useDaemonConfig(serverId);
const snapshot = useProvidersSnapshot(serverId);
const providers = useMemo(
() => buildSelectableProviderSelectorProviders(snapshot.entries),
[snapshot.entries],
);
const configuredProviders = config?.metadataGeneration.providers;
const configuredProvider = configuredProviders?.[0] ?? null;
const providers = useMemo(
() =>
buildSelectableProviderSelectorProviders(snapshot.entries, {
selectedProvider: configuredProvider?.provider ?? null,
}),
[configuredProvider?.provider, snapshot.entries],
);
const savedMode: SelectionMode = configuredProvider ? "preferred" : "automatic";
const [draftMode, setDraftMode] = useState<SelectionMode | null>(null);
const [isSaving, setIsSaving] = useState(false);
@@ -1,453 +0,0 @@
/**
* @vitest-environment jsdom
*/
import React, { act } from "react";
import { createRoot, type Root } from "react-dom/client";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import type { ProviderSnapshotEntry } from "@getpaseo/protocol/agent-types";
import type { MutableDaemonConfig } from "@getpaseo/protocol/messages";
import { ToastApiProvider } from "@/contexts/toast-api-context";
const { snapshotState, configState, patchConfigMock, openProviderSettingsMock } = vi.hoisted(
() => ({
snapshotState: {
entries: undefined as ProviderSnapshotEntry[] | undefined,
isLoading: false,
isRefreshing: false,
},
configState: {
config: null as MutableDaemonConfig | null,
},
patchConfigMock: vi.fn(async () => undefined),
openProviderSettingsMock: vi.fn(),
}),
);
vi.mock("react-native", async (importOriginal) => ({
...(await importOriginal<typeof import("react-native")>()),
View: ({ children, testID }: { children?: React.ReactNode; testID?: string }) =>
React.createElement("div", { "data-testid": testID }, children),
Text: ({ children }: { children?: React.ReactNode }) =>
React.createElement("span", null, children),
Pressable: ({
children,
onPress,
onHoverIn,
onHoverOut,
accessibilityRole,
accessibilityLabel,
disabled,
testID,
}: {
children?:
| React.ReactNode
| ((state: { pressed: boolean; hovered: boolean }) => React.ReactNode);
onPress?: (event: React.MouseEvent) => void;
onHoverIn?: () => void;
onHoverOut?: () => void;
accessibilityRole?: string;
accessibilityLabel?: string;
disabled?: boolean;
testID?: string;
}) =>
React.createElement(
"div",
{
role: accessibilityRole,
"aria-label": accessibilityLabel,
"aria-disabled": disabled ? "true" : undefined,
"data-testid": testID,
onClick: disabled ? undefined : onPress,
onMouseEnter: onHoverIn,
onMouseLeave: onHoverOut,
},
typeof children === "function" ? children({ pressed: false, hovered: false }) : children,
),
ActivityIndicator: () => React.createElement("span", { "data-testid": "activity-indicator" }),
}));
vi.mock("lucide-react-native", () => {
const icon = (name: string) => () => React.createElement("span", { "data-icon": name });
return {
ChevronRight: icon("ChevronRight"),
MoreHorizontal: icon("MoreHorizontal"),
Trash2: icon("Trash2"),
};
});
vi.mock("react-i18next", () => ({
useTranslation: () => ({
t: (key: string, values?: Record<string, string | number>) =>
(
({
"settings.providers.providerDetails": "{{name}} provider details",
"settings.providers.enableProvider": "Enable {{name}}",
"settings.providers.statuses.disabled": "Disabled",
"settings.providers.statuses.available": "Available",
"settings.providers.statuses.loading": "Loading",
"settings.providers.statuses.error": "Error",
"settings.providers.statuses.notInstalled": "Not installed",
"settings.providers.models.one": "1 model",
"settings.providers.models.many": "{{count}} models",
"settings.providers.addErrorTitle": "Unable to add provider",
"settings.providers.updateErrorTitle": "Unable to update provider",
"settings.providers.actions.menu": "{{name}} actions",
"settings.providers.actions.remove": "Remove provider",
"settings.providers.actions.removing": "Removing...",
"settings.providers.remove.confirmTitle": "Remove {{name}}?",
"settings.providers.remove.confirmMessage":
"This deletes the provider entry from config.json. It cannot be undone.",
"settings.providers.remove.confirm": "Remove",
"settings.providers.remove.errorTitle": "Unable to remove provider",
})[key] ?? key
)
.replaceAll("{{name}}", String(values?.name ?? ""))
.replaceAll("{{count}}", String(values?.count ?? "")),
}),
}));
vi.mock("@/components/ui/switch", () => ({
Switch: ({
value,
onValueChange,
disabled,
accessibilityLabel,
testID,
}: {
value: boolean;
onValueChange?: (next: boolean) => void;
disabled?: boolean;
accessibilityLabel?: string;
testID?: string;
}) =>
React.createElement("div", {
role: "switch",
"aria-checked": value ? "true" : "false",
"aria-disabled": disabled ? "true" : undefined,
"aria-label": accessibilityLabel,
"data-testid": testID ?? "provider-switch",
onClick: (event: React.MouseEvent) => {
event.stopPropagation();
if (disabled) return;
onValueChange?.(!value);
},
}),
}));
vi.mock("@/components/ui/loading-spinner", () => ({
LoadingSpinner: () => React.createElement("span", { "data-testid": "loading-spinner" }),
}));
vi.mock("@/components/settings/headings/settings-info-tip", () => ({
SettingsInfoTip: () => null,
}));
vi.mock("@/components/ui/external-link", () => ({
ExternalLink: () => null,
ExternalLinkLabel: () => null,
}));
vi.mock("@/components/ui/dropdown-menu", () => ({
DropdownMenu: ({ children }: { children?: React.ReactNode }) =>
React.createElement("div", null, children),
DropdownMenuTrigger: ({
children,
onPressIn,
accessibilityRole,
accessibilityLabel,
testID,
}: {
children?:
| React.ReactNode
| ((state: { pressed: boolean; hovered: boolean; open: boolean }) => React.ReactNode);
onPressIn?: (event: { stopPropagation: () => void }) => void;
accessibilityRole?: string;
accessibilityLabel?: string;
testID?: string;
}) =>
React.createElement(
"button",
{
type: "button",
role: accessibilityRole,
"aria-label": accessibilityLabel,
"data-testid": testID,
onMouseDown: (event: React.MouseEvent) => onPressIn?.(event),
onClick: (event: React.MouseEvent) => event.stopPropagation(),
},
typeof children === "function"
? children({ pressed: false, hovered: false, open: false })
: children,
),
DropdownMenuContent: ({ children }: { children?: React.ReactNode }) =>
React.createElement("div", null, children),
DropdownMenuItem: ({
children,
onSelect,
status,
pendingLabel,
testID,
}: {
children?: React.ReactNode;
onSelect?: () => void;
status?: "idle" | "pending" | "success";
pendingLabel?: string;
testID?: string;
}) =>
React.createElement(
"button",
{
type: "button",
"data-testid": testID,
disabled: status === "pending" || status === "success",
onClick: (event: React.MouseEvent) => {
event.stopPropagation();
onSelect?.();
},
},
status === "pending" ? pendingLabel : children,
),
}));
vi.mock("@/components/provider-icons", () => ({
useProviderIcon: (provider: string) => () =>
React.createElement("span", { "data-icon": `provider-${provider}` }),
}));
vi.mock("@/stores/provider-settings-store", () => ({
useProviderSettingsStore: (selector: (state: unknown) => unknown) =>
selector({ open: openProviderSettingsMock }),
}));
vi.mock("@/components/provider-catalog-list", () => ({
ProviderCatalogList: () => null,
}));
vi.mock("@/hooks/use-providers-snapshot", () => ({
useProvidersSnapshot: () => ({
entries: snapshotState.entries,
isLoading: snapshotState.isLoading,
isFetching: false,
isRefreshing: snapshotState.isRefreshing,
error: null,
supportsSnapshot: true,
refresh: vi.fn(async () => {}),
refetchIfStale: vi.fn(),
}),
}));
vi.mock("@/hooks/use-daemon-config", () => ({
useDaemonConfig: () => ({
config: configState.config,
isLoading: false,
patchConfig: patchConfigMock,
}),
}));
vi.mock("@/runtime/host-runtime", () => ({
useHostRuntimeIsConnected: () => true,
}));
vi.mock("@/runtime/host-features", () => ({
useHostFeature: () => false,
}));
vi.mock("@/utils/confirm-dialog", () => ({
confirmDialog: vi.fn(async () => true),
}));
import { ProvidersSection } from "./providers-section";
function unexpectedToast(): never {
throw new Error("Provider row interactions should not display a toast");
}
const toastApi = { show: unexpectedToast, copied: unexpectedToast, error: unexpectedToast };
const claudeEntry: ProviderSnapshotEntry = {
provider: "claude",
status: "ready",
enabled: true,
label: "Claude",
description: "Claude Code",
defaultModeId: null,
modes: [],
models: [
{ provider: "claude", id: "claude-opus-4-7", label: "Claude Opus 4.7" },
{ provider: "claude", id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6" },
{ provider: "claude", id: "claude-haiku-4-5", label: "Claude Haiku 4.5" },
],
};
const disabledCodexEntry: ProviderSnapshotEntry = {
provider: "codex",
status: "unavailable",
enabled: false,
label: "Codex",
description: "OpenAI Codex",
defaultModeId: null,
modes: [],
};
function makeConfig(providers: MutableDaemonConfig["providers"] = {}): MutableDaemonConfig {
return {
relay: { enabled: false },
mcp: { injectIntoAgents: false },
browserTools: { enabled: false },
providers,
metadataGeneration: { providers: [] },
autoArchiveAfterMerge: false,
enableTerminalAgentHooks: false,
appendSystemPrompt: "",
};
}
function descendants(el: HTMLElement): HTMLElement[] {
return Array.from(el.querySelectorAll<HTMLElement>("*"));
}
function indexOfMatches(nodes: HTMLElement[], selector: string): number {
return nodes.findIndex((node) => node.matches(selector));
}
function indexOfText(nodes: HTMLElement[], text: string): number {
return nodes.findIndex((node) => node.textContent?.trim() === text);
}
describe("ProvidersSection", () => {
let root: Root | null = null;
let container: HTMLElement | null = null;
beforeEach(() => {
vi.stubGlobal("React", React);
vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
container = document.createElement("div");
document.body.appendChild(container);
root = createRoot(container);
snapshotState.entries = undefined;
snapshotState.isLoading = false;
snapshotState.isRefreshing = false;
configState.config = null;
patchConfigMock.mockReset();
patchConfigMock.mockResolvedValue(undefined);
openProviderSettingsMock.mockReset();
});
afterEach(() => {
if (root) {
act(() => {
root?.unmount();
});
}
root = null;
container?.remove();
container = null;
vi.unstubAllGlobals();
});
function render(): void {
act(() => {
root?.render(
<ToastApiProvider api={toastApi}>
<ProvidersSection serverId="server-1" />
</ToastApiProvider>,
);
});
}
function findRow(accessibilityLabel: string): HTMLElement {
const row = container?.querySelector<HTMLElement>(
`[role="button"][aria-label="${accessibilityLabel}"]`,
);
if (!row) throw new Error(`Expected row with aria-label "${accessibilityLabel}"`);
return row;
}
it("renders the disabled provider with its server-provided label in snapshot order", () => {
snapshotState.entries = [claudeEntry, disabledCodexEntry];
configState.config = makeConfig({ codex: { enabled: false } });
render();
const rows = Array.from(
container?.querySelectorAll<HTMLElement>('[role="button"][aria-label$="provider details"]') ??
[],
);
expect(rows.map((row) => row.getAttribute("aria-label"))).toEqual([
"Claude provider details",
"Codex provider details",
]);
const codexRow = findRow("Codex provider details");
const codexNodes = descendants(codexRow);
expect(indexOfText(codexNodes, "Codex")).toBeGreaterThanOrEqual(0);
expect(indexOfText(codexNodes, "codex")).toBe(-1);
expect(indexOfText(codexNodes, "Disabled")).toBeGreaterThanOrEqual(0);
});
it("composes the row as chevron, icon, label, status, model count, then switch", () => {
snapshotState.entries = [claudeEntry];
configState.config = makeConfig();
render();
const row = findRow("Claude provider details");
const nodes = descendants(row);
const chevron = indexOfMatches(nodes, '[data-icon="ChevronRight"]');
const icon = indexOfMatches(nodes, '[data-icon="provider-claude"]');
const label = indexOfText(nodes, "Claude");
const status = indexOfText(nodes, "Available");
const modelCount = indexOfText(nodes, "3 models");
const switchEl = indexOfMatches(nodes, '[role="switch"]');
expect(chevron).toBeGreaterThanOrEqual(0);
expect(icon).toBeGreaterThan(chevron);
expect(label).toBeGreaterThan(icon);
expect(status).toBeGreaterThan(label);
expect(modelCount).toBeGreaterThan(status);
expect(switchEl).toBeGreaterThan(modelCount);
});
it("opens the diagnostic sheet when the outer row is pressed for a disabled provider", () => {
snapshotState.entries = [disabledCodexEntry];
configState.config = makeConfig({ codex: { enabled: false } });
render();
expect(openProviderSettingsMock).not.toHaveBeenCalled();
const row = findRow("Codex provider details");
act(() => {
row.dispatchEvent(new window.MouseEvent("click", { bubbles: true }));
});
expect(openProviderSettingsMock).toHaveBeenCalledTimes(1);
expect(openProviderSettingsMock).toHaveBeenCalledWith({
serverId: "server-1",
provider: "codex",
});
});
it("toggles the provider enabled flag through patchConfig when the switch is pressed", async () => {
snapshotState.entries = [claudeEntry];
configState.config = makeConfig();
render();
const row = findRow("Claude provider details");
const switchEl = row.querySelector<HTMLElement>('[role="switch"]');
expect(switchEl).not.toBeNull();
expect(switchEl?.getAttribute("aria-checked")).toBe("true");
await act(async () => {
switchEl?.dispatchEvent(new window.MouseEvent("click", { bubbles: true }));
});
expect(patchConfigMock).toHaveBeenCalledTimes(1);
expect(patchConfigMock).toHaveBeenCalledWith({
providers: { claude: { enabled: false } },
});
});
});

Some files were not shown because too many files have changed in this diff Show More