+}
+
+export function PluginSettingsOverview({
+ featureEnabled,
+ featureBusy,
+ settingsError,
+ loading,
+ refreshBusy,
+ error,
+ plugins,
+ busyPluginKeys,
+ openLogs,
+ logsByPlugin,
+ devPaths,
+ devPathsBusy,
+ onToggleFeature,
+ onRefresh,
+ onReview,
+ onToggleEnabled,
+ onToggleLogs,
+ onRemoveRequest,
+ onUpdateDevPaths
+}: PluginSettingsOverviewProps): React.JSX.Element {
+ return (
+ <>
+ {settingsError}
: null}
+
+ {!featureEnabled ? (
+
+ {translate(
+ 'auto.components.settings.PluginsSettingsSection.featureOff',
+ 'Turn on the plugin system to see and manage installed plugins. Anything already installed stays on disk and stays disabled while the system is off.'
+ )}
+
+ ) : loading ? (
+
+
+ ) : (
+ <>
+
+
+ {translate('auto.components.settings.PluginsSettingsSection.installed', 'Installed')}
+
+
+
+
+ {error ? (
+
+
{error}
+
+ {translate('auto.components.settings.PluginsSettingsSection.tryAgain', 'Try again')}
+
+
+ {translate(
+ 'auto.components.settings.PluginsSettingsSection.empty',
+ 'No plugins installed. Use Install plugin to add one from a local folder or a pinned git ref.'
+ )}
+
+ ) : (
+
+ {plugins.map((plugin) => (
+
+ ))}
+
+
+ {state?.loading ? (
+
+
+ ) : state?.error ? (
+
{state.error}
+ ) : (
+ <>
+
+ {state?.lines?.length
+ ? state.lines
+ .map(
+ (entry) =>
+ `${new Date(entry.ts).toLocaleTimeString()} ${entry.level.padEnd(5)} ${entry.line}`
+ )
+ .join('\n')
+ : translate(
+ 'auto.components.settings.PluginSettingsRow.noLogs',
+ 'No log lines recorded.'
+ )}
+
+
+
+ {translate(
+ 'auto.components.settings.PluginSettingsRow.logCount',
+ 'Last {{value0}} of up to 200 retained lines',
+ { value0: state?.lines?.length ?? 0 }
+ )}
+
+ {pluginKey}
+
+
+ )}
+
+
+
+
+ {plugin.name}
+ v{plugin.version}
+ {plugin.isDev ? (
+
+ {translate('auto.components.settings.PluginSettingsRow.dev', 'Dev')}
+
+ ) : null}
+
+
+ {busy ?
+
+ {plugin.publisher ? `${plugin.publisher} · ` : null}
+ {plugin.pluginKey}
+
+ {source ? (
+
+ {source}
+
+ ) : null}
+
+ {[...plugin.capabilities.map((capability) => capability.kind), trustTier(plugin)].join(
+ ' · '
+ )}
+
+ {plugin.error ? (
+
+
+ {plugin.status === 'invalid'
+ ? invalidPluginErrorMessage(plugin.error)
+ : translate(
+ 'auto.components.settings.PluginSettingsRow.runtimeError',
+ 'The plugin stopped after an activation or worker error.'
+ )}
+ {plugin.restarts > 0
+ ? translate(
+ 'auto.components.settings.PluginSettingsRow.restartCount',
+ ' · {{value0}} restarts',
+ { value0: plugin.restarts }
+ )
+ : null}
+
+
+ ) : null}
+
+
+ {needsReview ? (
+ onReview(plugin.pluginKey)}
+ >
+ {translate('auto.components.settings.PluginSettingsRow.review', 'Review permissions')}
+
+ ) : null}
+
+
+
+
+
+
+ onToggleLogs(plugin.pluginKey)}>
+
+ {!plugin.isDev ? (
+ onRemoveRequest(plugin.pluginKey)}
+ >
+
+ ) : null}
+
+
+ onToggleEnabled(plugin)}
+ ariaLabel={
+ enabled && !needsReview
+ ? translate(
+ 'auto.components.settings.PluginSettingsRow.disableLabel',
+ 'Disable {{value0}}',
+ { value0: plugin.name }
+ )
+ : translate(
+ 'auto.components.settings.PluginSettingsRow.enableLabel',
+ 'Enable {{value0}}',
+ { value0: plugin.name }
+ )
+ }
+ />
+
+
+ {logsOpen ?
: null}
+
+ {headerAction}
+ {children}
+
+ )
+}))
+
+vi.mock('../ui/dropdown-menu', () => ({
+ DropdownMenu: ({ children }: { children: React.ReactNode }) => {children}
,
+ DropdownMenuTrigger: ({ children }: { children: React.ReactNode }) => <>{children},
+ DropdownMenuContent: ({ children }: { children: React.ReactNode }) => {children}
,
+ DropdownMenuItem: ({
+ children,
+ onSelect
+ }: {
+ children: React.ReactNode
+ onSelect?: () => void
+ }) => {children}
+}))
+
+vi.mock('./PluginInstallDialog', () => ({ PluginInstallDialog: () => null }))
+vi.mock('./PluginConsentDialog', () => ({
+ PluginConsentDialog: ({
+ plugin,
+ onDecision
+ }: {
+ plugin: PluginHostListEntry | null
+ onDecision: (key: string, reviewedFingerprint: string, decision: 'approve') => Promise
+ }) => {
+ const [dirty, setDirty] = useState(false)
+ return plugin ? (
+ <>
+
+ void onDecision(plugin.pluginKey, plugin.consentFingerprint ?? '', 'approve')
+ }
+ >
+ Approve
+
+ setDirty(true)}>Mark consent dirty
+ {dirty ? Consent local state : null}
+
+ ) : null
+ }
+}))
+vi.mock('./PluginRemoveDialog', () => ({
+ PluginRemoveDialog: ({
+ plugin,
+ onConfirm
+ }: {
+ plugin: PluginHostListEntry | null
+ onConfirm: (key: string) => void
+ }) =>
+ plugin ? onConfirm(plugin.pluginKey)}>Confirm remove : null
+}))
+
+const plugin: PluginHostListEntry = {
+ pluginKey: 'acme.notes',
+ consentFingerprint: 'sha256-acme-notes',
+ name: 'Notes',
+ version: '1.0.0',
+ publisher: 'acme',
+ status: 'idle',
+ needsReconsent: false,
+ isDev: false,
+ capabilities: [{ kind: 'panels', description: 'Add a Notes panel' }],
+ panels: [],
+ commands: [],
+ hasWorker: false,
+ restarts: 0
+}
+
+const secondPlugin: PluginHostListEntry = {
+ ...plugin,
+ pluginKey: 'acme.tasks',
+ consentFingerprint: 'sha256-acme-tasks',
+ name: 'Tasks'
+}
+
+type Deferred = {
+ promise: Promise
+ resolve: (value: T) => void
+}
+
+function deferred(): Deferred {
+ let resolve!: (value: T) => void
+ const promise = new Promise((nextResolve) => {
+ resolve = nextResolve
+ })
+ return { promise, resolve }
+}
+
+function click(element: Element): void {
+ element.dispatchEvent(new MouseEvent('click', { bubbles: true }))
+}
+
+async function renderSection(
+ settings: GlobalSettings = { ...getDefaultSettings('/tmp'), pluginSystemEnabled: true },
+ updateSettings = vi.fn().mockResolvedValue(undefined),
+ mounted = true
+): Promise<{ root: Root; container: HTMLDivElement; updateSettings: typeof updateSettings }> {
+ const container = document.createElement('div')
+ document.body.appendChild(container)
+ const root = createRoot(container)
+ await act(async () => {
+ root.render(
+ = {}): {
+ unsubscribe: ReturnType
+} {
+ const unsubscribe = vi.fn()
+ Object.defineProperty(window, 'api', {
+ configurable: true,
+ value: {
+ plugins: {
+ list: vi.fn().mockResolvedValue([plugin]),
+ onChanged: vi.fn().mockReturnValue(unsubscribe),
+ refresh: vi.fn().mockResolvedValue([plugin]),
+ setEnabled: vi.fn().mockResolvedValue([{ ...plugin, status: 'disabled' }]),
+ remove: vi.fn().mockResolvedValue([]),
+ getLogs: vi.fn().mockResolvedValue([]),
+ consent: vi.fn().mockResolvedValue([plugin]),
+ install: vi.fn(),
+ ...overrides
+ }
+ }
+ })
+ return { unsubscribe }
+}
+
+beforeEach(() => installApi())
+
+afterEach(() => {
+ document.body.innerHTML = ''
+ vi.restoreAllMocks()
+})
+
+describe('PluginsSettingsSection lifecycle', () => {
+ it('defers discovery and its change listener until the pane is mounted', async () => {
+ const settings = { ...getDefaultSettings('/tmp'), pluginSystemEnabled: true }
+ const updateSettings = vi.fn().mockResolvedValue(undefined)
+ const { root } = await renderSection(settings, updateSettings, false)
+
+ expect(window.api.plugins.list).not.toHaveBeenCalled()
+ expect(window.api.plugins.onChanged).not.toHaveBeenCalled()
+
+ await act(async () => {
+ root.render(
+ ()
+ const second = deferred()
+ let onChanged: (() => void) | undefined
+ const { unsubscribe } = installApi({
+ list: vi.fn().mockReturnValueOnce(first.promise).mockReturnValueOnce(second.promise),
+ onChanged: vi.fn((callback: () => void) => {
+ onChanged = callback
+ return unsubscribe
+ })
+ })
+ const { root, container } = await renderSection()
+
+ act(() => onChanged?.())
+ await act(async () => second.resolve([{ ...plugin, name: 'Newer Notes' }]))
+ await act(async () => first.resolve([{ ...plugin, name: 'Older Notes' }]))
+
+ expect(container.textContent).toContain('Newer Notes')
+ expect(container.textContent).not.toContain('Older Notes')
+ act(() => root.unmount())
+ expect(unsubscribe).toHaveBeenCalledOnce()
+ })
+
+ it('persists the feature switch before refreshing discovery', async () => {
+ const updateSettings = vi.fn().mockResolvedValue(undefined)
+ const { container } = await renderSection(
+ { ...getDefaultSettings('/tmp'), pluginSystemEnabled: false },
+ updateSettings
+ )
+ const featureSwitch = container.querySelector('[aria-labelledby="plugin-system-label"]')
+ if (!featureSwitch) {
+ throw new Error('missing feature switch')
+ }
+ expect(window.api.plugins.list).not.toHaveBeenCalled()
+
+ await act(async () => click(featureSwitch))
+
+ expect(updateSettings).toHaveBeenCalledWith({ pluginSystemEnabled: true })
+ expect(window.api.plugins.refresh).toHaveBeenCalledOnce()
+ })
+
+ it('routes enablement and confirmed removal through plugin IPC', async () => {
+ const { container } = await renderSection()
+ const pluginSwitch = container.querySelector('[aria-label="Disable Notes"]')
+ if (!pluginSwitch) {
+ throw new Error('missing plugin switch')
+ }
+
+ await act(async () => click(pluginSwitch))
+ expect(window.api.plugins.setEnabled).toHaveBeenCalledWith({
+ pluginKey: plugin.pluginKey,
+ enabled: false
+ })
+ await act(async () => click(pluginSwitch))
+ expect(window.api.plugins.setEnabled).toHaveBeenLastCalledWith({
+ pluginKey: plugin.pluginKey,
+ enabled: true
+ })
+
+ const removeAction = Array.from(container.querySelectorAll('button')).find(
+ (button) => button.textContent === 'Remove'
+ )
+ if (!removeAction) {
+ throw new Error('missing remove action')
+ }
+ await act(async () => click(removeAction))
+ const confirm = Array.from(container.querySelectorAll('button')).find(
+ (button) => button.textContent === 'Confirm remove'
+ )
+ if (!confirm) {
+ throw new Error('missing remove confirmation')
+ }
+ await act(async () => click(confirm))
+ expect(window.api.plugins.remove).toHaveBeenCalledWith({ pluginKey: plugin.pluginKey })
+ })
+
+ it('accepts overlapping mutations in completion order without regressing final state', async () => {
+ const firstToggle = deferred()
+ const secondToggle = deferred()
+ installApi({
+ list: vi.fn().mockResolvedValue([plugin, secondPlugin]),
+ setEnabled: vi
+ .fn()
+ .mockReturnValueOnce(firstToggle.promise)
+ .mockReturnValueOnce(secondToggle.promise)
+ })
+ const { container } = await renderSection()
+ const notesSwitch = container.querySelector('[aria-label="Disable Notes"]')
+ const tasksSwitch = container.querySelector('[aria-label="Disable Tasks"]')
+ if (!notesSwitch || !tasksSwitch) {
+ throw new Error('missing plugin switches')
+ }
+
+ act(() => click(notesSwitch))
+ act(() => click(tasksSwitch))
+ expect(notesSwitch.disabled).toBe(true)
+ expect(tasksSwitch.disabled).toBe(true)
+
+ await act(async () => secondToggle.resolve([plugin, { ...secondPlugin, status: 'disabled' }]))
+
+ expect(notesSwitch.disabled).toBe(true)
+ expect(tasksSwitch.disabled).toBe(false)
+ await act(async () =>
+ firstToggle.resolve([
+ { ...plugin, status: 'disabled' },
+ { ...secondPlugin, status: 'disabled' }
+ ])
+ )
+ expect(notesSwitch.disabled).toBe(false)
+ expect(notesSwitch.getAttribute('aria-checked')).toBe('false')
+ expect(tasksSwitch.getAttribute('aria-checked')).toBe('false')
+ })
+
+ it('fetches bounded logs only when their disclosure opens', async () => {
+ const getLogs = vi.fn().mockResolvedValue([{ ts: 1, level: 'info', line: 'started' }])
+ installApi({ getLogs })
+ const { container } = await renderSection()
+ expect(getLogs).not.toHaveBeenCalled()
+ const viewLogs = Array.from(container.querySelectorAll('button')).find(
+ (button) => button.textContent === 'View logs'
+ )
+ if (!viewLogs) {
+ throw new Error('missing logs action')
+ }
+
+ await act(async () => click(viewLogs))
+
+ expect(getLogs).toHaveBeenCalledWith({ pluginKey: plugin.pluginKey })
+ expect(container.textContent).toContain('started')
+ })
+
+ it('shows supervised backoff as an enabled restarting plugin', async () => {
+ installApi({
+ list: vi.fn().mockResolvedValue([{ ...plugin, status: 'restarting', restarts: 1 }])
+ })
+ const { container } = await renderSection()
+ const pluginSwitch = container.querySelector('[aria-label="Disable Notes"]')
+
+ expect(container.textContent).toContain('Restarting')
+ expect(pluginSwitch?.getAttribute('aria-checked')).toBe('true')
+ })
+
+ it('prunes dialogs and stale logs after external removal and same-key reinstall', async () => {
+ const removedList = deferred()
+ const reinstalledList = deferred()
+ const oldLogs = deferred>>()
+ const freshLogs = deferred>>()
+ const pendingPlugin = { ...plugin, status: 'pending' as const }
+ let onChanged: (() => void) | undefined
+ const unsubscribe = vi.fn()
+ installApi({
+ list: vi
+ .fn()
+ .mockResolvedValueOnce([pendingPlugin])
+ .mockReturnValueOnce(removedList.promise)
+ .mockReturnValueOnce(reinstalledList.promise),
+ onChanged: vi.fn((callback: () => void) => {
+ onChanged = callback
+ return unsubscribe
+ }),
+ getLogs: vi.fn().mockReturnValueOnce(oldLogs.promise).mockReturnValueOnce(freshLogs.promise)
+ })
+ const { container } = await renderSection()
+ const findButton = (label: string): HTMLButtonElement | undefined =>
+ Array.from(container.querySelectorAll('button')).find(
+ (button) => button.textContent?.trim() === label
+ )
+
+ act(() => click(findButton('Review permissions')!))
+ act(() => click(findButton('Mark consent dirty')!))
+ act(() => click(findButton('View logs')!))
+ act(() => click(findButton('Remove')!))
+ expect(container.textContent).toContain('Consent local state')
+ expect(container.textContent).toContain('Confirm remove')
+
+ act(() => onChanged?.())
+ await act(async () => removedList.resolve([]))
+
+ expect(container.textContent).not.toContain('Approve')
+ expect(container.textContent).not.toContain('Confirm remove')
+ act(() => onChanged?.())
+ await act(async () => reinstalledList.resolve([pendingPlugin]))
+ expect(container.textContent).not.toContain('Loading logs…')
+
+ act(() => click(findButton('Review permissions')!))
+ expect(container.textContent).not.toContain('Consent local state')
+ act(() => click(findButton('View logs')!))
+ await act(async () => freshLogs.resolve([{ ts: 2, level: 'info', line: 'fresh installation' }]))
+ await act(async () => oldLogs.resolve([{ ts: 1, level: 'info', line: 'stale installation' }]))
+
+ expect(container.textContent).toContain('fresh installation')
+ expect(container.textContent).not.toContain('stale installation')
+ })
+
+ it('clears feature busy state and skips refresh when the setting write fails', async () => {
+ const updateSettings = vi.fn().mockRejectedValue(new Error('disk write failed'))
+ const { container } = await renderSection(
+ { ...getDefaultSettings('/tmp'), pluginSystemEnabled: false },
+ updateSettings
+ )
+ const featureSwitch = container.querySelector(
+ '[aria-labelledby="plugin-system-label"]'
+ )
+ if (!featureSwitch) {
+ throw new Error('missing feature switch')
+ }
+
+ await act(async () => click(featureSwitch))
+
+ expect(featureSwitch.disabled).toBe(false)
+ expect(window.api.plugins.refresh).not.toHaveBeenCalled()
+ expect(container.textContent).toContain('Could not save plugin settings.')
+ })
+
+ it('persists verbatim development paths and refreshes discovery', async () => {
+ const updateSettings = vi.fn().mockResolvedValue(undefined)
+ const { container } = await renderSection(undefined, updateSettings)
+ const input = container.querySelector('details input')
+ if (!input) {
+ throw new Error('missing development path input')
+ }
+ await act(async () => {
+ Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')?.set?.call(
+ input,
+ 'C:\\plugins\\demo'
+ )
+ input.dispatchEvent(new Event('input', { bubbles: true }))
+ })
+ const add = Array.from(container.querySelectorAll('button')).find(
+ (button) => button.textContent === 'Add path'
+ )
+ if (!add) {
+ throw new Error('missing add path action')
+ }
+
+ await act(async () => click(add))
+
+ expect(updateSettings).toHaveBeenCalledWith({ devPluginPaths: ['C:\\plugins\\demo'] })
+ expect(window.api.plugins.refresh).toHaveBeenCalled()
+ })
+
+ it('preserves development input and clears busy when adding a path fails', async () => {
+ const updateSettings = vi.fn().mockRejectedValue(new Error('disk write failed'))
+ const { container } = await renderSection(undefined, updateSettings)
+ const input = container.querySelector('details input')
+ if (!input) {
+ throw new Error('missing development path input')
+ }
+ await act(async () => {
+ Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')?.set?.call(
+ input,
+ '/plugins/demo'
+ )
+ input.dispatchEvent(new Event('input', { bubbles: true }))
+ })
+ const add = Array.from(container.querySelectorAll('button')).find(
+ (button) => button.textContent === 'Add path'
+ )
+ if (!add) {
+ throw new Error('missing add path action')
+ }
+
+ await act(async () => click(add))
+
+ expect(input.value).toBe('/plugins/demo')
+ expect(add.disabled).toBe(false)
+ expect(window.api.plugins.refresh).not.toHaveBeenCalled()
+ expect(container.textContent).toContain('Could not save plugin settings.')
+ })
+
+ it('keeps a development path and handles a failed removal without rejection', async () => {
+ const updateSettings = vi.fn().mockRejectedValue(new Error('disk write failed'))
+ const settings = {
+ ...getDefaultSettings('/tmp'),
+ pluginSystemEnabled: true,
+ devPluginPaths: ['/plugins/demo']
+ }
+ const { container } = await renderSection(settings, updateSettings)
+ const remove = Array.from(container.querySelectorAll('button')).find(
+ (button) => button.textContent === 'Remove' && button.closest('details')
+ )
+ if (!remove) {
+ throw new Error('missing development path remove action')
+ }
+
+ await act(async () => click(remove))
+
+ expect(container.textContent).toContain('/plugins/demo')
+ expect(remove.disabled).toBe(false)
+ expect(window.api.plugins.refresh).not.toHaveBeenCalled()
+ expect(container.textContent).toContain('Could not save plugin settings.')
+ })
+})
diff --git a/src/renderer/src/components/settings/PluginsSettingsSection.tsx b/src/renderer/src/components/settings/PluginsSettingsSection.tsx
new file mode 100644
index 00000000000..82d8b81784d
--- /dev/null
+++ b/src/renderer/src/components/settings/PluginsSettingsSection.tsx
@@ -0,0 +1,426 @@
+import { useEffect, useRef, useState } from 'react'
+import { Plus } from 'lucide-react'
+import type {
+ PluginHostInstallSource,
+ PluginHostListEntry,
+ PluginHostLogLine
+} from '../../../../preload/api-types'
+import type { GlobalSettings } from '../../../../shared/types'
+import { translate } from '@/i18n/i18n'
+import { Button } from '../ui/button'
+import { PluginConsentDialog } from './PluginConsentDialog'
+import { PluginInstallDialog } from './PluginInstallDialog'
+import { PluginRemoveDialog } from './PluginRemoveDialog'
+import { PluginSettingsOverview } from './PluginSettingsOverview'
+import type { PluginLogsState } from './PluginSettingsRow'
+import { getPluginsPaneSearchEntries } from './plugins-search'
+import { SettingsSection } from './SettingsSection'
+
+type PluginsSettingsSectionProps = {
+ mounted: boolean
+ settings: GlobalSettings
+ updateSettings: (updates: Partial) => Promise
+}
+
+function errorMessage(cause: unknown, fallback: string): string {
+ console.warn('[plugins] settings action failed:', cause)
+ return fallback
+}
+
+export function PluginsSettingsSection({
+ mounted,
+ settings,
+ updateSettings
+}: PluginsSettingsSectionProps): React.JSX.Element {
+ const [plugins, setPlugins] = useState([])
+ const [loading, setLoading] = useState(true)
+ const [error, setError] = useState(null)
+ const [installOpen, setInstallOpen] = useState(false)
+ const [consentPluginId, setConsentPluginId] = useState(null)
+ const [removePluginId, setRemovePluginId] = useState(null)
+ const [busyPluginKeys, setBusyPluginKeys] = useState>(() => new Set())
+ const [featureBusy, setFeatureBusy] = useState(false)
+ const [refreshBusy, setRefreshBusy] = useState(false)
+ const [devPathsBusy, setDevPathsBusy] = useState(false)
+ const [settingsError, setSettingsError] = useState(null)
+ const [openLogs, setOpenLogs] = useState>(() => new Set())
+ const [logsByPlugin, setLogsByPlugin] = useState>({})
+ const mountedRef = useRef(false)
+ const listRequestRef = useRef(0)
+ const nextLogsRequestRef = useRef(0)
+ const logsRequestRef = useRef>({})
+
+ const applyPluginList = (nextPlugins: PluginHostListEntry[]): void => {
+ const installedPluginKeys = new Set(nextPlugins.map((plugin) => plugin.pluginKey))
+ setPlugins(nextPlugins)
+ setError(null)
+ // Why: accepted discovery results own installed-plugin identity and invalidate stale UI state.
+ setConsentPluginId((current) => (current && installedPluginKeys.has(current) ? current : null))
+ setRemovePluginId((current) => (current && installedPluginKeys.has(current) ? current : null))
+ setBusyPluginKeys(
+ (current) => new Set([...current].filter((pluginKey) => installedPluginKeys.has(pluginKey)))
+ )
+ setOpenLogs(
+ (current) => new Set([...current].filter((pluginKey) => installedPluginKeys.has(pluginKey)))
+ )
+ setLogsByPlugin((current) =>
+ Object.fromEntries(
+ Object.entries(current).filter(([pluginKey]) => installedPluginKeys.has(pluginKey))
+ )
+ )
+ for (const pluginKey of Object.keys(logsRequestRef.current)) {
+ if (!installedPluginKeys.has(pluginKey)) {
+ delete logsRequestRef.current[pluginKey]
+ }
+ }
+ }
+
+ const setPluginListError = (cause: unknown): void => {
+ setError(
+ errorMessage(
+ cause,
+ translate(
+ 'auto.components.settings.PluginsSettingsSection.loadFailed',
+ 'Could not load plugins.'
+ )
+ )
+ )
+ }
+
+ const loadPluginList = async (
+ request: Promise
+ ): Promise => {
+ const requestId = ++listRequestRef.current
+ try {
+ const nextPlugins = await request
+ if (!mountedRef.current || requestId !== listRequestRef.current) {
+ return null
+ }
+ applyPluginList(nextPlugins)
+ return nextPlugins
+ } catch (cause) {
+ if (mountedRef.current && requestId === listRequestRef.current) {
+ setPluginListError(cause)
+ }
+ return null
+ }
+ }
+
+ const applyCompletedMutation = (nextPlugins: PluginHostListEntry[]): void => {
+ if (!mountedRef.current) {
+ return
+ }
+ // Why: a mutation result is authoritative at completion time, even when an earlier action
+ // finishes after a later-started action or a passive refresh is still in flight.
+ listRequestRef.current += 1
+ applyPluginList(nextPlugins)
+ }
+
+ useEffect(() => {
+ mountedRef.current = mounted
+ if (!mounted) {
+ // Why: hidden lazy panes must not resurrect dialogs or unresolved async state when reopened.
+ setPlugins([])
+ setLoading(true)
+ setError(null)
+ setInstallOpen(false)
+ setConsentPluginId(null)
+ setRemovePluginId(null)
+ setBusyPluginKeys(new Set())
+ setFeatureBusy(false)
+ setRefreshBusy(false)
+ setDevPathsBusy(false)
+ setSettingsError(null)
+ setOpenLogs(new Set())
+ setLogsByPlugin({})
+ logsRequestRef.current = {}
+ }
+ return () => {
+ mountedRef.current = false
+ listRequestRef.current += 1
+ }
+ }, [mounted])
+
+ useEffect(() => {
+ if (!mounted || !settings.pluginSystemEnabled) {
+ return
+ }
+ setLoading(true)
+ const load = async (): Promise => {
+ await loadPluginList(window.api.plugins.list())
+ if (mountedRef.current) {
+ setLoading(false)
+ }
+ }
+ void load()
+ const unsubscribe = window.api.plugins.onChanged(() => {
+ void loadPluginList(window.api.plugins.list())
+ })
+ return () => {
+ listRequestRef.current += 1
+ unsubscribe()
+ }
+ }, [mounted, settings.pluginSystemEnabled])
+
+ const sectionPresentation = {
+ title: translate('auto.components.settings.PluginsSettingsSection.title', 'Plugins'),
+ badge: translate(
+ 'auto.components.settings.PluginsSettingsSection.experimental',
+ 'Experimental'
+ ),
+ description: translate(
+ 'auto.components.settings.PluginsSettingsSection.description',
+ 'Install and manage Orca plugins. Plugins run on this computer, even for SSH workspaces.'
+ ),
+ searchEntries: getPluginsPaneSearchEntries()
+ }
+
+ if (!mounted) {
+ return => {
+ setFeatureBusy(true)
+ setSettingsError(null)
+ setError(null)
+ try {
+ await updateSettings({ pluginSystemEnabled: !settings.pluginSystemEnabled })
+ await loadPluginList(window.api.plugins.refresh())
+ } catch {
+ if (mountedRef.current) {
+ setSettingsError(
+ translate(
+ 'auto.components.settings.PluginsSettingsSection.settingsUpdateFailed',
+ 'Could not save plugin settings.'
+ )
+ )
+ }
+ } finally {
+ if (mountedRef.current) {
+ setFeatureBusy(false)
+ }
+ }
+ }
+
+ const install = async (source: PluginHostInstallSource): Promise => {
+ const result = await window.api.plugins.install(source)
+ if (!result.ok) {
+ throw new Error(result.error)
+ }
+ // Why: installation is not consent; select by id and wait for the authoritative list.
+ setInstallOpen(false)
+ setConsentPluginId(result.pluginKey)
+ await loadPluginList(window.api.plugins.refresh())
+ }
+
+ const decideConsent = async (
+ pluginKey: string,
+ reviewedFingerprint: string,
+ decision: 'approve' | 'keep-disabled'
+ ): Promise => {
+ setBusyPluginKeys((current) => new Set(current).add(pluginKey))
+ try {
+ const nextPlugins = await window.api.plugins.consent({
+ pluginKey,
+ reviewedFingerprint,
+ decision
+ })
+ applyCompletedMutation(nextPlugins)
+ if (mountedRef.current) {
+ setConsentPluginId(null)
+ }
+ } finally {
+ if (mountedRef.current) {
+ setBusyPluginKeys((current) => {
+ const next = new Set(current)
+ next.delete(pluginKey)
+ return next
+ })
+ }
+ }
+ }
+
+ const toggleEnabled = async (plugin: PluginHostListEntry): Promise => {
+ const enabled =
+ plugin.status === 'running' ||
+ plugin.status === 'restarting' ||
+ plugin.status === 'idle' ||
+ plugin.status === 'errored'
+ setBusyPluginKeys((current) => new Set(current).add(plugin.pluginKey))
+ try {
+ const nextPlugins = await window.api.plugins.setEnabled({
+ pluginKey: plugin.pluginKey,
+ enabled: !enabled
+ })
+ applyCompletedMutation(nextPlugins)
+ } catch (cause) {
+ if (mountedRef.current) {
+ setPluginListError(cause)
+ }
+ } finally {
+ if (mountedRef.current) {
+ setBusyPluginKeys((current) => {
+ const next = new Set(current)
+ next.delete(plugin.pluginKey)
+ return next
+ })
+ }
+ }
+ }
+
+ const remove = async (pluginKey: string): Promise => {
+ setBusyPluginKeys((current) => new Set(current).add(pluginKey))
+ try {
+ const nextPlugins = await window.api.plugins.remove({ pluginKey })
+ applyCompletedMutation(nextPlugins)
+ if (mountedRef.current) {
+ setRemovePluginId(null)
+ }
+ } catch (cause) {
+ if (mountedRef.current) {
+ setPluginListError(cause)
+ }
+ } finally {
+ if (mountedRef.current) {
+ setBusyPluginKeys((current) => {
+ const next = new Set(current)
+ next.delete(pluginKey)
+ return next
+ })
+ }
+ }
+ }
+
+ const refresh = async (): Promise => {
+ setRefreshBusy(true)
+ await loadPluginList(window.api.plugins.refresh())
+ if (mountedRef.current) {
+ setRefreshBusy(false)
+ }
+ }
+
+ const toggleLogs = (pluginKey: string): void => {
+ if (openLogs.has(pluginKey)) {
+ setOpenLogs((current) => {
+ const next = new Set(current)
+ next.delete(pluginKey)
+ return next
+ })
+ return
+ }
+ setOpenLogs((current) => new Set(current).add(pluginKey))
+ if (logsByPlugin[pluginKey]?.lines) {
+ return
+ }
+ const requestId = ++nextLogsRequestRef.current
+ logsRequestRef.current[pluginKey] = requestId
+ setLogsByPlugin((current) => ({ ...current, [pluginKey]: { loading: true } }))
+ void window.api.plugins
+ .getLogs({ pluginKey })
+ .then((lines: PluginHostLogLine[]) => {
+ if (mountedRef.current && logsRequestRef.current[pluginKey] === requestId) {
+ setLogsByPlugin((current) => ({
+ ...current,
+ [pluginKey]: { loading: false, lines }
+ }))
+ }
+ })
+ .catch((cause: unknown) => {
+ if (mountedRef.current && logsRequestRef.current[pluginKey] === requestId) {
+ setLogsByPlugin((current) => ({
+ ...current,
+ [pluginKey]: {
+ loading: false,
+ error: errorMessage(
+ cause,
+ translate(
+ 'auto.components.settings.PluginsSettingsSection.logsFailed',
+ 'Could not load plugin logs.'
+ )
+ )
+ }
+ }))
+ }
+ })
+ }
+
+ const updateDevPaths = async (paths: string[]): Promise => {
+ setDevPathsBusy(true)
+ setSettingsError(null)
+ try {
+ await updateSettings({ devPluginPaths: paths })
+ await loadPluginList(window.api.plugins.refresh())
+ } catch {
+ const message = translate(
+ 'auto.components.settings.PluginsSettingsSection.settingsUpdateFailed',
+ 'Could not save plugin settings.'
+ )
+ if (mountedRef.current) {
+ setSettingsError(message)
+ }
+ throw new Error(message)
+ } finally {
+ if (mountedRef.current) {
+ setDevPathsBusy(false)
+ }
+ }
+ }
+
+ const featureEnabled = settings.pluginSystemEnabled
+ return (
+ setInstallOpen(true)}
+ >
+ void toggleFeature()}
+ onRefresh={() => void refresh()}
+ onReview={setConsentPluginId}
+ onToggleEnabled={(entry) => void toggleEnabled(entry)}
+ onToggleLogs={toggleLogs}
+ onRemoveRequest={setRemovePluginId}
+ onUpdateDevPaths={updateDevPaths}
+ />
+ setRemovePluginId(null)}
+ onConfirm={(pluginKey) => void remove(pluginKey)}
+ />
+
+ )
+}
diff --git a/src/renderer/src/components/settings/Settings.tsx b/src/renderer/src/components/settings/Settings.tsx
index 2d5a941226c..6e977c10e27 100644
--- a/src/renderer/src/components/settings/Settings.tsx
+++ b/src/renderer/src/components/settings/Settings.tsx
@@ -47,6 +47,7 @@ import { NotificationsPane } from './NotificationsPane'
import { VoicePane } from './VoicePane'
import { SshPane } from './SshPane'
import { ExperimentalPane } from './ExperimentalPane'
+import { PluginsSettingsSection } from './PluginsSettingsSection'
import { AgentsPane } from './AgentsPane'
import { OrchestrationPane } from './OrchestrationPane'
import { AccountsPane } from './AccountsPane'
@@ -271,6 +272,7 @@ function Settings(): React.JSX.Element {
const settings = useAppStore((s) => s.settings)
const keybindings = useAppStore((s) => s.keybindings)
const updateSettings = useAppStore((s) => s.updateSettings)
+ const updateSettingsOrThrow = useAppStore((s) => s.updateSettingsOrThrow)
const switchRuntimeEnvironment = useAppStore((s) => s.switchRuntimeEnvironment)
const fetchSettings = useAppStore((s) => s.fetchSettings)
const fetchKeybindings = useAppStore((s) => s.fetchKeybindings)
@@ -1646,6 +1648,14 @@ function Settings(): React.JSX.Element {
) : null}
+ {showDesktopOnlySettings ? (
+
+ settingsSet.mockResolvedValueOnce(authoritativeSettings)
+ const store = createTestStore()
+ store.setState({
+ settings: {
+ pluginSystemEnabled: false,
+ notifications: {}
+ } as unknown as AppState['settings']
+ })
+
+ await expect(
+ store.getState().updateSettingsOrThrow({ pluginSystemEnabled: true })
+ ).resolves.toBeUndefined()
+
+ expect(settingsSet).toHaveBeenCalledWith({ pluginSystemEnabled: true })
+ expect(store.getState().settings).toBe(authoritativeSettings)
+ })
+
+ it('rejects a failed checked update without changing local settings', async () => {
+ const persistenceError = new Error('settings IPC failed')
+ const currentSettings = {
+ pluginSystemEnabled: false,
+ notifications: {}
+ } as unknown as NonNullable
+ settingsSet.mockRejectedValueOnce(persistenceError)
+ const store = createTestStore()
+ store.setState({ settings: currentSettings })
+
+ await expect(
+ store.getState().updateSettingsOrThrow({ pluginSystemEnabled: true })
+ ).rejects.toBe(persistenceError)
+
+ expect(store.getState().settings).toBe(currentSettings)
+ })
+
+ it('keeps the existing update action best-effort and logs persistence failures', async () => {
+ const persistenceError = new Error('settings IPC failed')
+ const currentSettings = {
+ pluginSystemEnabled: false,
+ notifications: {}
+ } as unknown as NonNullable
+ settingsSet.mockRejectedValueOnce(persistenceError)
+ const consoleError = vi.spyOn(console, 'error').mockImplementation(() => undefined)
+ const store = createTestStore()
+ store.setState({ settings: currentSettings })
+
+ try {
+ await expect(
+ store.getState().updateSettings({ pluginSystemEnabled: true })
+ ).resolves.toBeUndefined()
+
+ expect(consoleError).toHaveBeenCalledWith('Failed to update settings:', persistenceError)
+ expect(store.getState().settings).toBe(currentSettings)
+ } finally {
+ consoleError.mockRestore()
+ }
+ })
+})
+
describe('createSettingsSlice runtime switching', () => {
it('repairs drifted task provider settings before sending updates', async () => {
settingsSet.mockResolvedValueOnce({
diff --git a/src/renderer/src/store/slices/settings.ts b/src/renderer/src/store/slices/settings.ts
index f9d4d4f3699..3c3c4d1f2db 100644
--- a/src/renderer/src/store/slices/settings.ts
+++ b/src/renderer/src/store/slices/settings.ts
@@ -28,6 +28,7 @@ export type SettingsSlice = SettingsSearchState & {
settings: GlobalSettings | null
fetchSettings: () => Promise
updateSettings: (updates: Partial) => Promise
+ updateSettingsOrThrow: (updates: Partial) => Promise
switchRuntimeEnvironment: (environmentId: string | null) => Promise
}
@@ -35,6 +36,8 @@ type LegacyTerminalScrollbackSettingsUpdate = Partial & {
terminalScrollbackBytes?: unknown
}
+type SettingsStateSetter = Parameters>[0]
+
function normalizeRuntimeEnvironmentId(value: string | null | undefined): string | null {
const trimmed = value?.trim()
return trimmed ? trimmed : null
@@ -47,6 +50,77 @@ function createOpenInApplicationId(): string {
)
}
+function normalizeSettingsUpdates(
+ updates: Partial,
+ currentSettings: GlobalSettings | null
+): Partial {
+ const { terminalScrollbackBytes: _legacyScrollbackBytes, ...sanitizedUpdates } =
+ updates as LegacyTerminalScrollbackSettingsUpdate
+ void _legacyScrollbackBytes
+ if ('terminalQuickCommands' in updates) {
+ sanitizedUpdates.terminalQuickCommands = normalizeTerminalQuickCommands(
+ updates.terminalQuickCommands
+ )
+ }
+ if ('terminalCustomThemes' in updates) {
+ sanitizedUpdates.terminalCustomThemes = normalizeTerminalCustomThemes(
+ updates.terminalCustomThemes
+ )
+ }
+ if ('visibleTaskProviders' in updates || 'defaultTaskSource' in updates) {
+ const taskProviderSettings = normalizeTaskProviderSettings({
+ visibleTaskProviders:
+ 'visibleTaskProviders' in updates
+ ? updates.visibleTaskProviders
+ : currentSettings?.visibleTaskProviders,
+ defaultTaskSource:
+ 'defaultTaskSource' in updates
+ ? updates.defaultTaskSource
+ : currentSettings?.defaultTaskSource
+ })
+ sanitizedUpdates.defaultTaskSource = taskProviderSettings.defaultTaskSource
+ sanitizedUpdates.visibleTaskProviders = taskProviderSettings.visibleTaskProviders
+ }
+ if ('openInApplications' in updates) {
+ sanitizedUpdates.openInApplications = normalizeOpenInApplications(updates.openInApplications, {
+ createId: createOpenInApplicationId
+ })
+ }
+ if ('disabledTuiAgents' in updates) {
+ sanitizedUpdates.disabledTuiAgents = normalizeDisabledTuiAgents(updates.disabledTuiAgents)
+ }
+ if ('agentDefaultArgs' in updates) {
+ sanitizedUpdates.agentDefaultArgs = normalizeTuiAgentArgsRecord(updates.agentDefaultArgs)
+ sanitizedUpdates.agentYoloDefaultsMigrated = true
+ }
+ if ('agentDefaultEnv' in updates) {
+ sanitizedUpdates.agentDefaultEnv = normalizeTuiAgentEnvRecord(updates.agentDefaultEnv)
+ sanitizedUpdates.agentYoloDefaultsMigrated = true
+ }
+ if ('uiLanguage' in updates) {
+ sanitizedUpdates.uiLanguage = normalizeUiLanguage(updates.uiLanguage)
+ }
+ if ('terminalScrollbackRows' in updates) {
+ sanitizedUpdates.terminalScrollbackRows = normalizeDesktopTerminalScrollbackRows(
+ updates.terminalScrollbackRows
+ )
+ }
+ return sanitizedUpdates
+}
+
+async function persistSettingsUpdates(
+ set: SettingsStateSetter,
+ updates: Partial,
+ currentSettings: GlobalSettings | null
+): Promise {
+ const nextSettings = await window.api.settings.set(
+ normalizeSettingsUpdates(updates, currentSettings)
+ )
+ set((state) => ({
+ settings: (nextSettings as GlobalSettings | undefined) ?? state.settings
+ }))
+}
+
async function verifyRuntimeEnvironmentReachable(environmentId: string | null): Promise {
if (!environmentId) {
return
@@ -81,67 +155,16 @@ export const createSettingsSlice: StateCreator
updateSettings: async (updates) => {
try {
- const { terminalScrollbackBytes: _legacyScrollbackBytes, ...sanitizedUpdates } =
- updates as LegacyTerminalScrollbackSettingsUpdate
- void _legacyScrollbackBytes
- if ('terminalQuickCommands' in updates) {
- sanitizedUpdates.terminalQuickCommands = normalizeTerminalQuickCommands(
- updates.terminalQuickCommands
- )
- }
- if ('terminalCustomThemes' in updates) {
- sanitizedUpdates.terminalCustomThemes = normalizeTerminalCustomThemes(
- updates.terminalCustomThemes
- )
- }
- if ('visibleTaskProviders' in updates || 'defaultTaskSource' in updates) {
- const taskProviderSettings = normalizeTaskProviderSettings({
- visibleTaskProviders:
- 'visibleTaskProviders' in updates
- ? updates.visibleTaskProviders
- : get().settings?.visibleTaskProviders,
- defaultTaskSource:
- 'defaultTaskSource' in updates
- ? updates.defaultTaskSource
- : get().settings?.defaultTaskSource
- })
- sanitizedUpdates.defaultTaskSource = taskProviderSettings.defaultTaskSource
- sanitizedUpdates.visibleTaskProviders = taskProviderSettings.visibleTaskProviders
- }
- if ('openInApplications' in updates) {
- sanitizedUpdates.openInApplications = normalizeOpenInApplications(
- updates.openInApplications,
- {
- createId: createOpenInApplicationId
- }
- )
- }
- if ('disabledTuiAgents' in updates) {
- sanitizedUpdates.disabledTuiAgents = normalizeDisabledTuiAgents(updates.disabledTuiAgents)
- }
- if ('agentDefaultArgs' in updates) {
- sanitizedUpdates.agentDefaultArgs = normalizeTuiAgentArgsRecord(updates.agentDefaultArgs)
- sanitizedUpdates.agentYoloDefaultsMigrated = true
- }
- if ('agentDefaultEnv' in updates) {
- sanitizedUpdates.agentDefaultEnv = normalizeTuiAgentEnvRecord(updates.agentDefaultEnv)
- sanitizedUpdates.agentYoloDefaultsMigrated = true
- }
- if ('uiLanguage' in updates) {
- sanitizedUpdates.uiLanguage = normalizeUiLanguage(updates.uiLanguage)
- }
- if ('terminalScrollbackRows' in updates) {
- sanitizedUpdates.terminalScrollbackRows = normalizeDesktopTerminalScrollbackRows(
- updates.terminalScrollbackRows
- )
- }
- const nextSettings = await window.api.settings.set(sanitizedUpdates)
- set((s) => ({ settings: (nextSettings as GlobalSettings | undefined) ?? s.settings }))
+ await persistSettingsUpdates(set, updates, get().settings)
} catch (err) {
console.error('Failed to update settings:', err)
}
},
+ updateSettingsOrThrow: async (updates) => {
+ await persistSettingsUpdates(set, updates, get().settings)
+ },
+
switchRuntimeEnvironment: async (environmentId) => {
const nextId = normalizeRuntimeEnvironmentId(environmentId)
const previousId = normalizeRuntimeEnvironmentId(get().settings?.activeRuntimeEnvironmentId)
diff --git a/src/shared/plugins/plugin-demo-fixture.test.ts b/src/shared/plugins/plugin-demo-fixture.test.ts
new file mode 100644
index 00000000000..d499cb4e279
--- /dev/null
+++ b/src/shared/plugins/plugin-demo-fixture.test.ts
@@ -0,0 +1,20 @@
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { describe, expect, it } from 'vitest'
+import { pluginManifestSchema } from './plugin-manifest'
+
+describe('hello Orca plugin fixture', () => {
+ it('uses an ESM entry that remains loadable outside a type-module package', async () => {
+ const root = join(process.cwd(), 'examples', 'plugins', 'hello-orca')
+ const manifest = pluginManifestSchema.parse(
+ JSON.parse(await readFile(join(root, 'orca-plugin.json'), 'utf8'))
+ )
+
+ expect(manifest.main).toBe('main.mjs')
+ const workerModule = (await import(pathToFileURL(join(root, manifest.main!)).href)) as {
+ default?: unknown
+ }
+ expect(workerModule.default).toBeTypeOf('function')
+ })
+})
diff --git a/tests/e2e/plugin-demo.spec.ts b/tests/e2e/plugin-demo.spec.ts
new file mode 100644
index 00000000000..860e1aac1f1
--- /dev/null
+++ b/tests/e2e/plugin-demo.spec.ts
@@ -0,0 +1,180 @@
+/**
+ * Invariant: the documented hello-orca plugin stays inert before visible
+ * consent, then its panel, worker command, and event subscription all work.
+ */
+
+import { cp, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import type { Page } from '@stablyai/playwright-test'
+import { expect, test } from './helpers/orca-app'
+
+async function openPluginSettings(page: Page): Promise {
+ await page.evaluate(() => {
+ const state = window.__store?.getState()
+ if (!state) {
+ throw new Error('store unavailable')
+ }
+ state.openSettingsTarget({ pane: 'plugins', repoId: null })
+ state.openSettingsPage()
+ })
+ await expect(page.locator('[data-settings-section="plugins"]')).toBeVisible()
+}
+
+async function openDemoPanel(page: Page): Promise {
+ await page.evaluate(() => {
+ const state = window.__store?.getState()
+ if (!state) {
+ throw new Error('store unavailable')
+ }
+ state.closeSettingsPage()
+ if (!state.rightSidebarOpen) {
+ state.toggleRightSidebar()
+ }
+ })
+ const panelButton = page.getByRole('button', { name: 'Hello Orca', exact: true })
+ await expect(panelButton).toBeVisible({ timeout: 15_000 })
+ await panelButton.click()
+ const frame = page.frameLocator('iframe[title="Hello Orca"]')
+ await expect(frame.getByRole('heading', { name: 'Hello Orca 👋' })).toBeVisible()
+ await expect(frame.locator('meta[http-equiv="Content-Security-Policy"]')).toHaveAttribute(
+ 'content',
+ /default-src 'none'/
+ )
+}
+
+async function createWorktree(page: Page, name: string): Promise {
+ await page.waitForFunction(
+ () => {
+ const state = window.__store?.getState()
+ return Boolean(state && Object.values(state.worktreesByRepo).flat().length > 0)
+ },
+ undefined,
+ { timeout: 15_000 }
+ )
+ return page.evaluate(async (worktreeName) => {
+ const state = window.__store?.getState()
+ if (!state) {
+ throw new Error('store unavailable')
+ }
+ const worktrees = Object.values(state.worktreesByRepo).flat()
+ const active =
+ worktrees.find((worktree) => worktree.id === state.activeWorktreeId) ?? worktrees[0]
+ if (!active) {
+ throw new Error('active worktree was not found')
+ }
+ const result = await state.createWorktree(active.repoId, worktreeName)
+ return result.worktree.id
+ }, name)
+}
+
+test('runs hello-orca panel, command, and event behind visible consent', async ({ orcaPage }) => {
+ const tempRoot = await mkdtemp(join(tmpdir(), 'orca-hello-plugin-e2e-'))
+ const pluginRoot = join(tempRoot, 'hello-orca')
+ let createdWorktreeId: string | null = null
+ await cp(join(process.cwd(), 'examples', 'plugins', 'hello-orca'), pluginRoot, {
+ recursive: true
+ })
+
+ try {
+ const installed = await orcaPage.evaluate(async (sourcePath) => {
+ const settings = await window.api.settings.set({ pluginSystemEnabled: true })
+ window.__store?.setState({ settings })
+ const result = await window.api.plugins.install({ kind: 'local-path', path: sourcePath })
+ if (!result.ok) {
+ throw new Error(result.error)
+ }
+ const pending = (await window.api.plugins.refresh()).find(
+ (entry) => entry.pluginKey === result.pluginKey
+ )
+ if (!pending) {
+ throw new Error('installed plugin was not listed')
+ }
+ let blocked = false
+ try {
+ await window.api.plugins.invokeCommand({
+ pluginKey: result.pluginKey,
+ commandId: 'hello-ping',
+ args: { source: 'before-consent' }
+ })
+ } catch {
+ blocked = true
+ }
+ return { pluginKey: result.pluginKey, status: pending.status, blocked }
+ }, pluginRoot)
+
+ expect(installed.status).toBe('pending')
+ expect(installed.blocked).toBe(true)
+
+ await openPluginSettings(orcaPage)
+ const row = orcaPage.locator(`[data-plugin-key="${installed.pluginKey}"]`)
+ await expect(row).toContainText('Needs review')
+ await row.getByRole('button', { name: 'Review permissions' }).click()
+ const consent = orcaPage.getByRole('dialog', { name: 'Review permissions' })
+ await expect(consent).toBeVisible()
+ await expect(consent).toContainText(pluginRoot)
+ await expect(consent).toContainText('full access to your files, network, and other processes')
+ await expect(consent.getByRole('button', { name: 'Keep Disabled' })).toBeFocused()
+ await consent.getByRole('button', { name: 'Enable plugin' }).click()
+ await expect(consent).toBeHidden()
+ await expect(row).toContainText('Enabled')
+
+ const commandResults = await orcaPage.evaluate(async (pluginKey) => {
+ const first = await window.api.plugins.invokeCommand({
+ pluginKey,
+ commandId: 'hello-ping',
+ args: { source: 'e2e' }
+ })
+ const second = await window.api.plugins.invokeCommand({
+ pluginKey,
+ commandId: 'hello-ping',
+ args: { source: 'e2e' }
+ })
+ return { first, second }
+ }, installed.pluginKey)
+ expect(commandResults.first).toEqual({ pong: true, count: 1, args: { source: 'e2e' } })
+ expect(commandResults.second).toEqual({ pong: true, count: 2, args: { source: 'e2e' } })
+
+ await orcaPage.evaluate(async (sourcePath) => {
+ const settings = await window.api.settings.set({ devPluginPaths: [sourcePath] })
+ window.__store?.setState({ settings })
+ await window.api.plugins.refresh()
+ }, pluginRoot)
+
+ await openDemoPanel(orcaPage)
+
+ const panelPath = join(pluginRoot, 'panel.html')
+ const panelHtml = await readFile(panelPath, 'utf8')
+ await writeFile(panelPath, panelHtml.replace('Hello Orca 👋', 'Hello Orca reloaded'))
+ await expect(
+ orcaPage.frameLocator('iframe[title="Hello Orca"]').getByRole('heading', {
+ name: 'Hello Orca reloaded'
+ })
+ ).toBeVisible({ timeout: 15_000 })
+
+ createdWorktreeId = await createWorktree(orcaPage, `plugin-event-${Date.now()}`)
+ await expect
+ .poll(
+ () =>
+ orcaPage.evaluate(
+ async ({ pluginKey, worktreeId }) =>
+ (await window.api.plugins.getLogs({ pluginKey })).some(
+ (entry) =>
+ entry.line.includes('worktree created:') && entry.line.includes(worktreeId)
+ ),
+ { pluginKey: installed.pluginKey, worktreeId: createdWorktreeId! }
+ ),
+ { timeout: 15_000 }
+ )
+ .toBe(true)
+ } finally {
+ if (createdWorktreeId) {
+ await orcaPage
+ .evaluate(async (worktreeId) => {
+ await window.__store?.getState().removeWorktree(worktreeId, true)
+ }, createdWorktreeId)
+ .catch(() => undefined)
+ }
+ await rm(tempRoot, { recursive: true, force: true })
+ }
+})