You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
{{ message }}
Repository navigation
omarchy plugin add --enable: one-shot enablePlugin IPC times out ("omarchy-shell is not responding") while the shell is still rebuilding plugins; plugin lands installed but disabled #9304
omarchy plugin add <url> --enable --yes cloned and installed the plugin, then failed the enable half:
Cloning into '/home/noc/.config/omarchy/plugins/.add.tmp.948032'...
Added io.github.nocstah.omachill into /home/noc/.config/omarchy/plugins/io.github.nocstah.omachill
omarchy-shell is not responding
omarchy plugin list afterwards shows the plugin installed but disabled. Running omarchy plugin enable <id> a few seconds later succeeds every time.
Why (traced through the scripts)
omarchy-plugin-add calls omarchy-shell shell rescanPlugins, then polls omarchy-plugin-list --json (IPC listPlugins) for up to 40 × 0.05 s until the id appears, then calls omarchy-plugin-enable exactly once.
omarchy-plugin-enable runs omarchy-shell shell enablePlugin "$id" "$placement" — a single IPC call.
omarchy-shell wraps every call in timeout 2s (ipc_timeout=${OMARCHY_SHELL_IPC_TIMEOUT:-2s}) and maps exit 124 to omarchy-shell is not responding (bin/omarchy-shell:59–63).
After the rescan the shell is in finishPluginReload → Qt.clearComponentCache() → recreating every panel, service and bar widget synchronously (shell.qml). With enough installed plugins that stretch blocks the QML event loop for more than 2 s, so the discovery poll (answered during/right after scanning) succeeds while the one-shot enablePlugin call that follows it times out.
So the race is between the enable call and the shell's own plugin reconstruction that omarchy-plugin-add itself triggered one step earlier. The discovery loop is given patience; the enable call is not.
The same 2 s window can also bite a bare omarchy plugin enable/disable run immediately after any write under ~/.config/omarchy/plugins/ (the inotify watcher starts the same reload).
Reproduce
On a shell with many plugins installed (15 third-party here — the reload takes several seconds; a nearly stock install usually wins the race):
omarchy plugin add https://github.com/nocstah/omachill --enable --yes
# → "Added ..." then "omarchy-shell is not responding"; plugin left disabled
omarchy plugin enable io.github.nocstah.omachill # succeeds
Reproduced twice on 2026-08-30 (17:11 +07 via plugin add --enable; also with a plain enable right after an rsync into the plugins dir). The shell was healthy throughout — omarchy-shell shell ping answers ok once the reload finishes.
Expected
Either the enable call gets the same patience the discovery poll already gets (retry on timeout for a few seconds), or enablePlugin is queued by the shell when it arrives mid-reload. Since omarchy-plugin-add knows it just triggered the reload, a bounded retry around step 2 seems like the smallest fix.
Hit this on Omarchy 4.0.3-1 (version file says 4.0.0.alpha), AMD 9950X3D, 19
plugins installed. Same message, same outcome — installed but not enabled —
but I measured it failing one call earlier than this trace describes, so
adding the evidence here rather than opening a third issue.
The earlier failure point
omarchy-plugin-add runs with set -euo pipefail (line 9) and calls
omarchy-shell shell rescanPlugins >/dev/null # line 149
unguarded. When that call is the one that exceeds the 2 s budget, omarchy-shellexit 1s (fail(), bin/omarchy-shell:13–17, 62) and set -e
aborts the script there — before the discovery poll and before omarchy-plugin-enable is ever reached. So there are two ways to reach
"installed but disabled":
the one traced above — rescan completes, enablePlugin times out;
the rescan itself times out and the script never gets as far as enabling.
This is the same defect @-referenced in #11115 (set -e over an unguarded rescanPlugins), but in omarchy-plugin-add rather than omarchy-plugin-update, and here it costs the enable rather than just the
exit code.
Deterministic reproduction
No need to race it — shrink the budget the script already honours:
Cloning into '~/.config/omarchy/plugins/.add.tmp.3148325'...
Added lancefaul.omarcal into ~/.config/omarchy/plugins/lancefaul.omarcal
omarchy-shell is not responding
exit=1
~/.config/omarchy/shell.json is unchanged — the widget never reaches the
bar — while the plugin folder is on disk. omarchy plugin enable <id>
afterwards works every time, as described above.
How close to the limit this is in practice
Ten omarchy-shell shell rescanPlugins runs, 1.5 s apart, on that 19-plugin
bar:
rescan time
timeouts
my plugin installed
1758–2004 ms
1/10
my plugin removed
1653–2004 ms
2/10
The baseline sits at roughly 1.8 s against a 2.0 s ceiling, and it times out
with my plugin removed as readily as with it installed. So this is not
about any one heavy plugin: on a bar with enough of them the rescan is
marginal for everybody, and whichever call lands on the wrong side of 2 s
takes the install with it.
(I did reduce my own plugin's contribution — deferring a large QML component
and its startup work took it from 4/8 failures to indistinguishable from not
being installed. That is worth doing as a plugin author, but it only changes
who tips the balance, not that the balance is this tight.)
Suggestion
Whatever the right timeout is, rescanPlugins failing shouldn't cost the --enable half of an install the user asked for. Guarding that one call
(|| true, or the same patience the discovery poll already gets) would turn
both failure modes into a slow install instead of a half-finished one.
Reproduced on current quattro (7f95505), on a worker installed from the Omarchy ISO. I ran a throwaway shell from that tree, with a test plugin that keeps the shell's event loop busy for a few seconds on each plugin reload.
What I found:
The enable timeout (this report).omarchy plugin add --enable sets off two full plugin reloads: one from rescanPlugins, and one from the plugins directory watcher after the mv. The second one is queued and runs as soon as the first finishes. The discovery poll sees the new plugin between the two, so the single enablePlugin call arrives while the second reload is rebuilding the bar. If that rebuild takes more than omarchy-shell's 2s timeout, the enable fails with omarchy-shell is not responding and exits 1. With the reload held for 3.5s, an enable sent 0.3s after it failed at 2.0s in 3 runs out of 3. The full plugin add --enable failed this way in 2 runs out of 5. On quattro the shell still ran the timed-out enable once it was free, and the plugin showed up enabled a few seconds later. That is a change from 4.0.1, where it stayed disabled. The cause is the newer socket path in omarchy-shell, which hands the request to the shell before waiting for the answer.
The rescan abort (@lancefaul's comment). This is still present: rescanPlugins at bin/omarchy-plugin-add:149 is unguarded under set -e, so if that call times out, plugin add stops before it ever tries to enable. Make the closing plugin rescan best-effort #11117 already makes that rescan best-effort, in add, clone, remove and update, so I have not opened a second fix for it.
#14710 gives omarchy-plugin-enable's one shell call up to 10s, unless OMARCHY_SHELL_IPC_TIMEOUT is set. With it, the same enable succeeded at 3.5–3.6s in 5 runs out of 5. ./test/cli and the plugin enable, add and clone shell tests pass on the worker. The discovery poll can still print a transient omarchy-shell is not responding before it succeeds; those lines are noise, not failures.
Codex Medium reviewed the diagnosis and the fix separately. It found the same mechanism and no defect in the change, and it pointed out that one long block alone cannot explain the failure, because discovery already waited for the shell to answer. That is how the second reload came to light. Its agreement was not independent: it read the same code with my question in front of it.
Activity
lancefaul commentedon Sep 20, 2026
Hit this on Omarchy 4.0.3-1 (version file says 4.0.0.alpha), AMD 9950X3D, 19
plugins installed. Same message, same outcome — installed but not enabled —
but I measured it failing one call earlier than this trace describes, so
adding the evidence here rather than opening a third issue.
The earlier failure point
omarchy-plugin-addruns withset -euo pipefail(line 9) and callsunguarded. When that call is the one that exceeds the 2 s budget,
omarchy-shellexit 1s (fail(), bin/omarchy-shell:13–17, 62) andset -eaborts the script there — before the discovery poll and before
omarchy-plugin-enableis ever reached. So there are two ways to reach"installed but disabled":
enablePlugintimes out;This is the same defect @-referenced in #11115 (
set -eover an unguardedrescanPlugins), but inomarchy-plugin-addrather thanomarchy-plugin-update, and here it costs the enable rather than just theexit code.
Deterministic reproduction
No need to race it — shrink the budget the script already honours:
~/.config/omarchy/shell.jsonis unchanged — the widget never reaches thebar — while the plugin folder is on disk.
omarchy plugin enable <id>afterwards works every time, as described above.
How close to the limit this is in practice
Ten
omarchy-shell shell rescanPluginsruns, 1.5 s apart, on that 19-pluginbar:
The baseline sits at roughly 1.8 s against a 2.0 s ceiling, and it times out
with my plugin removed as readily as with it installed. So this is not
about any one heavy plugin: on a bar with enough of them the rescan is
marginal for everybody, and whichever call lands on the wrong side of 2 s
takes the install with it.
(I did reduce my own plugin's contribution — deferring a large QML component
and its startup work took it from 4/8 failures to indistinguishable from not
being installed. That is worth doing as a plugin author, but it only changes
who tips the balance, not that the balance is this tight.)
Suggestion
Whatever the right timeout is,
rescanPluginsfailing shouldn't cost the--enablehalf of an install the user asked for. Guarding that one call(
|| true, or the same patience the discovery poll already gets) would turnboth failure modes into a slow install instead of a half-finished one.
omarchybot commentedon Oct 9, 2026
Reproduced on current
quattro(7f95505), on a worker installed from the Omarchy ISO. I ran a throwaway shell from that tree, with a test plugin that keeps the shell's event loop busy for a few seconds on each plugin reload.What I found:
omarchy plugin add --enablesets off two full plugin reloads: one fromrescanPlugins, and one from the plugins directory watcher after themv. The second one is queued and runs as soon as the first finishes. The discovery poll sees the new plugin between the two, so the singleenablePlugincall arrives while the second reload is rebuilding the bar. If that rebuild takes more thanomarchy-shell's 2s timeout, the enable fails withomarchy-shell is not respondingand exits 1. With the reload held for 3.5s, an enable sent 0.3s after it failed at 2.0s in 3 runs out of 3. The fullplugin add --enablefailed this way in 2 runs out of 5. Onquattrothe shell still ran the timed-out enable once it was free, and the plugin showed up enabled a few seconds later. That is a change from 4.0.1, where it stayed disabled. The cause is the newer socket path inomarchy-shell, which hands the request to the shell before waiting for the answer.rescanPluginsatbin/omarchy-plugin-add:149is unguarded underset -e, so if that call times out,plugin addstops before it ever tries to enable. Make the closing plugin rescan best-effort #11117 already makes that rescan best-effort, inadd,clone,removeandupdate, so I have not opened a second fix for it.#14710 gives
omarchy-plugin-enable's one shell call up to 10s, unlessOMARCHY_SHELL_IPC_TIMEOUTis set. With it, the same enable succeeded at 3.5–3.6s in 5 runs out of 5../test/cliand the plugin enable, add and clone shell tests pass on the worker. The discovery poll can still print a transientomarchy-shell is not respondingbefore it succeeds; those lines are noise, not failures.Codex Medium reviewed the diagnosis and the fix separately. It found the same mechanism and no defect in the change, and it pointed out that one long block alone cannot explain the failure, because discovery already waited for the shell to answer. That is how the second reload came to light. Its agreement was not independent: it read the same code with my question in front of it.
#14710 and #11117 now wait on the maintainer.