@rxtx4816/cockpit-plugin-base-react 1.0.1 → 1.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 RXTX4816
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,86 @@
+# @rxtx4816/cockpit-plugin-base-react
+
+Shared foundation for building [Cockpit](https://cockpit-project.org/) plugins with React and PatternFly v6. Extracts the boilerplate that every plugin needs — bootstrapping, i18n, dark theme, async patterns, systemd integration, shared tooling config, and a full QEMU VM test harness — so each plugin only contains its own logic.
+
+## What's included
+
+**Plugin runtime**
+- `bootstrapPlugin` — mounts your React app into the Cockpit frame with i18n and error boundary wired up
+- `dark-theme` — side-effect module that automatically syncs the `pf-v6-theme-dark` class with the Cockpit shell, responding to user preference changes and system theme
+- `initCockpitI18n` — sets up i18next with Cockpit's locale loading conventions
+
+**Hooks**
+- `useAsyncAction` — wraps an async operation with `loading`, `error`, and `execute` state; ideal for buttons that trigger backend calls
+- `useAutoRefresh` — runs a callback on a configurable interval, with manual refresh support
+- `useAsyncStream` — consumes a Cockpit channel as a line-buffered async stream
+- `useConfirmAction` — multi-step confirmation flow with typed state transitions
+- `usePollingFetch` — fetch with automatic polling, refresh, and loading state
+
+**Components**
+- `ConfirmDialog` — confirmation modal driven by `useConfirmAction`, supports multi-step flows
+- `ErrorBoundary` — catches render errors and shows a PatternFly alert with details
+- `HelpPopover` — PatternFly popover for contextual help text
+- `LogViewer` — scrollable terminal-style log display backed by an async stream
+- `StatusBadge` — color-coded badge for service or resource states
+- `ToastProvider` + hook — global toast notification system
+
+**Systemd layer**
+- `useServiceStatus` — reactive hook for a systemd service state (active, failed, inactive…)
+- `ServiceControl` — start/stop/restart/enable control component
+- `api` — typed wrappers around `cockpit.spawn` for systemctl operations
+
+**Shared tooling config**
+- `tsconfig.base.json` — TypeScript base config tuned for Cockpit plugins
+- `eslint.config.base` — `createEslintConfig()` factory with TS, React, and react-hooks rules
+- `vitest.config.base` — Vitest base config with jsdom and PatternFly setup
+
+**Testing utilities**
+- Vitest setup file that installs jsdom and jest-dom matchers
+- `mockCockpit` — in-memory Cockpit API mock for unit tests
+- `mockHttpClient` — mock for Cockpit HTTP client used in tests
+
+**QEMU VM test harness**
+- `npm run vm` — spins up real cloud VMs (Arch, Debian, Fedora) with Cockpit installed and your plugin mounted via virtfs. Used for end-to-end testing against a live Cockpit instance. See [VM Testing](docs/wiki/VM-Testing.md).
+
+**Reusable CI/CD workflows**
+- Lint, typecheck, test, and build on every push
+- RPM, DEB, and Arch package build verification
+- Semantic version bumping from conventional commits
+- Automated release asset upload and AUR publishing
+- GitHub Wiki sync from `docs/wiki/`
+
+## Install
+
+```bash
+npm install @rxtx4816/cockpit-plugin-base-react
+```
+
+Peer dependencies: `react >=19`, `react-dom >=19`, `i18next >=26`, `react-i18next >=17`
+
+## Quick start
+
+```tsx
+// src/index.tsx
+import "./i18n";
+import "@rxtx4816/cockpit-plugin-base-react/dark-theme";
+import { bootstrapPlugin } from "@rxtx4816/cockpit-plugin-base-react/bootstrap";
+import App from "./App";
+
+bootstrapPlugin(App);
+```
+
+For full setup guidance, config sharing, and workflow integration see the [wiki](docs/wiki/Home.md).
+
+## Documentation
+
+- [Getting Started](docs/wiki/Getting-Started.md)
+- [Hooks](docs/wiki/Hooks.md)
+- [Components](docs/wiki/Components.md)
+- [Systemd Layer](docs/wiki/Systemd.md)
+- [Testing](docs/wiki/Testing.md)
+- [VM Testing](docs/wiki/VM-Testing.md)
+- [CI/CD Workflows](docs/wiki/CI-CD.md)
+
+## License
+
+MIT © 2026 RXTX4816

package/docs/wiki/CI-CD.md

@@ -0,0 +1,87 @@
+# CI/CD Workflows
+
+The package ships reusable GitHub Actions workflows that plugins call with `uses:`. This keeps CI logic in one place and lets all plugins inherit fixes and improvements automatically.
+
+## Using the workflows
+
+In your plugin's `.github/workflows/`:
+
+```yaml
+# .github/workflows/ci.yml
+name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  ci:
+    uses: RXTX4816/cockpit-plugin-base-react/.github/workflows/ci-plugin.yml@main
+    with:
+      plugin-name: cockpit-caddy
+```
+
+---
+
+## Available workflows
+
+### ci-plugin.yml
+
+Runs on every push and pull request. Steps: lint → typecheck → test → build → verify build output.
+
+Required inputs:
+- `plugin-name` — used to verify `src/main.js` and `src/main.css` exist after build
+
+### pkg-ci-plugin.yml
+
+Builds and verifies RPM, DEB, and Arch packages using a placeholder `0.0.0` version. Confirms that the packaging definitions (`.spec`, `debian/`, `PKGBUILD`) are valid before a real release.
+
+Required inputs:
+- `plugin-name`
+- `spec-file` — path to the RPM spec file (e.g. `cockpit-caddy.spec`)
+- `aur-pkgname` — AUR package name
+
+### semantic-release-plugin.yml
+
+Determines the next version from conventional commits since the last git tag and creates the tag. Does not build or publish anything — it only tags. The tag then triggers whatever release workflow you have listening on `push.tags`.
+
+Version bump rules:
+- `BREAKING CHANGE` anywhere in a commit body → major
+- `feat:` prefix → minor
+- anything else → patch
+- no commits since last tag → skip (exits 0, no tag created)
+
+Required secrets:
+- `RELEASE_TOKEN` — a GitHub token with `contents: write` permission
+
+Optional inputs:
+- `initial_version` — version to use when no prior tag exists (default: `v1.0.0`)
+
+### release-plugin.yml
+
+Builds release assets (tarball + sha256, RPM, DEB) and uploads them to a GitHub release. Also updates the `PKGBUILD` and pushes to AUR.
+
+Required inputs:
+- `plugin-name`, `spec-file`, `aur-pkgname`
+- `maintainer-name`, `maintainer-email`
+
+Required secrets:
+- `AUR_SSH_KEY` — SSH private key registered with the AUR account
+- `RELEASE_TOKEN` — GitHub token with `contents: write`
+
+### sync-wiki-plugin.yml
+
+Copies all `.md` files from `docs/wiki/` in your plugin repo to the GitHub Wiki. Triggered by push to main.
+
+No inputs or secrets required beyond the default `GITHUB_TOKEN`.
+
+---
+
+## Secrets reference
+
+| Secret | Used by | Description |
+|---|---|---|
+| `RELEASE_TOKEN` | semantic-release, release | GitHub PAT with `contents: write` |
+| `AUR_SSH_KEY` | release | SSH private key for AUR pushes |
+| `NPM_TOKEN` | (base package only) | npm automation token for publishing |

package/docs/wiki/Components.md

@@ -0,0 +1,56 @@
+# Components
+
+All components are exported from the components entrypoint:
+
+```ts
+import { ConfirmDialog, ErrorBoundary, HelpPopover, LogViewer, StatusBadge, ToastProvider } from "@rxtx4816/cockpit-plugin-base-react/components";
+```
+
+`ToastProvider` is mounted automatically by `bootstrapPlugin`. The others are available for use anywhere in your plugin.
+
+---
+
+## ConfirmDialog
+
+A PatternFly modal dialog driven by `useConfirmAction` state. Supports multi-step confirmation flows — for example, showing a warning first and requiring the user to type a resource name before proceeding.
+
+Receives the `state` and `cancel` from `useConfirmAction` and renders the appropriate step content.
+
+---
+
+## ErrorBoundary
+
+A React error boundary that catches render errors anywhere in the component tree and displays a PatternFly alert with the error message and stack trace. Prevents the entire plugin from going blank on an unexpected error.
+
+Mounted automatically by `bootstrapPlugin`, but can also be used to wrap specific subtrees.
+
+---
+
+## HelpPopover
+
+A small PatternFly popover for contextual help. Renders a help icon button that opens a popover with a title and body text. Use it next to form fields or section headings to explain non-obvious behaviour.
+
+---
+
+## LogViewer
+
+A scrollable, terminal-style log display that accepts an array of output lines (typically from `useAsyncStream`). Automatically scrolls to the bottom on new output. Used for displaying real-time command output or service journal entries.
+
+---
+
+## StatusBadge
+
+A color-coded label for service or resource states. Maps state strings (e.g. `"active"`, `"failed"`, `"inactive"`, `"unknown"`) to PatternFly status colors. Used by `ServiceControl` and can be used standalone wherever you need to display a state.
+
+---
+
+## ToastProvider
+
+Global toast notification context. Wrap your app with `ToastProvider` (done automatically by `bootstrapPlugin`) and use the `useToast` hook to fire notifications from anywhere:
+
+```ts
+const { addToast } = useToast();
+addToast({ title: "Saved", variant: "success" });
+```
+
+Toasts are displayed in the top-right corner and auto-dismiss after a configurable timeout.

package/docs/wiki/Getting-Started.md

@@ -0,0 +1,92 @@
+# Getting Started
+
+## Installation
+
+```bash
+npm install @rxtx4816/cockpit-plugin-base-react
+```
+
+Peer dependencies required in your plugin:
+
+```bash
+npm install react react-dom i18next react-i18next
+```
+
+---
+
+## Bootstrapping your plugin
+
+Every Cockpit plugin needs an entry point that initialises i18n, the dark theme, and mounts React. This package handles all of it:
+
+```tsx
+// src/index.tsx
+import "./i18n";
+import "@rxtx4816/cockpit-plugin-base-react/dark-theme";
+import { bootstrapPlugin } from "@rxtx4816/cockpit-plugin-base-react/bootstrap";
+import App from "./App";
+
+bootstrapPlugin(App);
+```
+
+`bootstrapPlugin` wraps your app in an `ErrorBoundary` and a `ToastProvider`, then mounts it into the `#app` element that Cockpit expects.
+
+---
+
+## i18n setup
+
+Create `src/i18n.ts` in your plugin:
+
+```ts
+import { initCockpitI18n } from "@rxtx4816/cockpit-plugin-base-react/i18n";
+
+initCockpitI18n();
+```
+
+This sets up i18next with Cockpit's locale loading conventions so `useTranslation()` works throughout your plugin.
+
+---
+
+## Shared tooling config
+
+Extend from the base configs so all plugins stay consistent.
+
+**tsconfig.json**
+```json
+{
+  "extends": "@rxtx4816/cockpit-plugin-base-react/tsconfig.base.json",
+  "compilerOptions": {
+    "paths": {}
+  }
+}
+```
+
+**eslint.config.js**
+```js
+import { createEslintConfig } from "@rxtx4816/cockpit-plugin-base-react/eslint.config.base";
+
+export default createEslintConfig();
+```
+
+Pass extra globals if your plugin uses custom Cockpit types:
+```js
+export default createEslintConfig({ CockpitHttpClient: "readonly" });
+```
+
+**vitest.config.ts**
+```ts
+import { defineConfig } from "@rxtx4816/cockpit-plugin-base-react/vitest.config.base";
+
+export default defineConfig();
+```
+
+---
+
+## Dark theme
+
+Importing the `dark-theme` side-effect module is all that's needed. It listens for three signals and keeps the `pf-v6-theme-dark` class on `<html>` in sync:
+
+- `localStorage` key `shell:style` (values: `"light"`, `"dark"`, `"auto"`)
+- The custom `cockpit-style` event dispatched by the Cockpit shell switcher
+- The OS-level `prefers-color-scheme` media query
+
+No configuration required.

package/docs/wiki/Home.md

@@ -0,0 +1,13 @@
+# cockpit-plugin-base-react Wiki
+
+This wiki covers everything you need to build, test, and ship Cockpit plugins using `@rxtx4816/cockpit-plugin-base-react`.
+
+## Contents
+
+- [Getting Started](Getting-Started.md) — install, bootstrap, and first plugin setup
+- [Hooks](Hooks.md) — async state, polling, streams, confirmation flows
+- [Components](Components.md) — UI building blocks: toasts, dialogs, logs, badges
+- [Systemd Layer](Systemd.md) — service status, control, and typed API wrappers
+- [Testing](Testing.md) — unit testing with mocked Cockpit and HTTP client
+- [VM Testing](VM-Testing.md) — end-to-end testing with real QEMU VMs
+- [CI/CD Workflows](CI-CD.md) — reusable GitHub Actions for builds, packages, and releases

package/docs/wiki/Hooks.md

@@ -0,0 +1,58 @@
+# Hooks
+
+All hooks are exported from the main entrypoint:
+
+```ts
+import { useAsyncAction, useAutoRefresh, useAsyncStream, useConfirmAction, usePollingFetch } from "@rxtx4816/cockpit-plugin-base-react";
+```
+
+---
+
+## useAsyncAction
+
+Wraps an async operation with `loading`, `error`, and `execute` state. Designed for buttons or forms that trigger backend calls.
+
+The hook returns an object with:
+- `execute(...args)` — triggers the operation
+- `loading` — true while the operation is in progress
+- `error` — the caught error if the operation failed, or null
+- `reset()` — clears error state
+
+Errors are caught automatically; unhandled promise rejections do not propagate to the component tree.
+
+---
+
+## useAutoRefresh
+
+Runs a callback on a configurable interval. Returns a `refresh()` function for on-demand triggering and a `loading` flag.
+
+Useful for periodically re-fetching data without managing `setInterval` lifecycle yourself. The interval is cleared on unmount.
+
+---
+
+## useAsyncStream
+
+Consumes a Cockpit channel as a line-buffered async stream. Returns the accumulated output lines and an `error` state.
+
+Used internally by `LogViewer` and useful anywhere you need to display or process real-time output from a spawned process.
+
+---
+
+## useConfirmAction
+
+Manages a multi-step confirmation flow with typed state transitions. Returns:
+
+- `state` — current step or `null` when idle
+- `start(initialStep)` — opens the flow
+- `next(step)` — advances to the next step
+- `cancel()` — resets to idle
+
+Pairs with `ConfirmDialog` to build destructive action flows (e.g. delete with a typed confirmation).
+
+---
+
+## usePollingFetch
+
+Fetches a resource with automatic polling and returns `{ data, loading, error, refresh }`. The poll interval is configurable.
+
+Handles the full lifecycle: initial fetch, polling, cleanup on unmount, and error recovery. Calling `refresh()` triggers an immediate re-fetch and resets the poll timer.

package/docs/wiki/Systemd.md

@@ -0,0 +1,43 @@
+# Systemd Layer
+
+The systemd layer provides typed hooks, a control component, and low-level API wrappers for interacting with systemd services through Cockpit.
+
+```ts
+import { useServiceStatus, ServiceControl } from "@rxtx4816/cockpit-plugin-base-react/systemd";
+```
+
+---
+
+## useServiceStatus
+
+Reactive hook that tracks the state of a systemd service. Polls via `systemctl is-active` and returns:
+
+- `status` — one of `"active"`, `"inactive"`, `"failed"`, `"activating"`, `"deactivating"`, `"unknown"`
+- `loading` — true on the initial fetch
+- `error` — any error from the underlying `cockpit.spawn` call
+- `refresh()` — manually re-check the service state
+
+The hook automatically re-polls at a configurable interval, so your UI stays in sync without manual management.
+
+---
+
+## ServiceControl
+
+A self-contained component that renders start/stop/restart/enable/disable buttons for a named service. Internally uses `useServiceStatus` for the current state and the `api` helpers to dispatch commands.
+
+Buttons are disabled while an operation is in progress. Status changes are reflected immediately via an optimistic state update, then confirmed by the next poll.
+
+---
+
+## API helpers
+
+Low-level typed wrappers around `cockpit.spawn` for common systemctl operations:
+
+- `startService(name)` — `systemctl start`
+- `stopService(name)` — `systemctl stop`
+- `restartService(name)` — `systemctl restart`
+- `enableService(name)` — `systemctl enable`
+- `disableService(name)` — `systemctl disable`
+- `getServiceStatus(name)` — returns the current active state string
+
+All functions return Promises and throw on non-zero exit codes.

package/docs/wiki/Testing.md

@@ -0,0 +1,51 @@
+# Testing
+
+## Setup
+
+The package ships a Vitest setup file that configures jsdom and installs jest-dom matchers. Reference it from your plugin's `vitest.config.ts` (handled automatically when you extend the base config):
+
+```ts
+import { defineConfig } from "@rxtx4816/cockpit-plugin-base-react/vitest.config.base";
+export default defineConfig();
+```
+
+---
+
+## Test utilities
+
+```ts
+import { mockCockpit, mockHttpClient } from "@rxtx4816/cockpit-plugin-base-react/testing/helpers";
+```
+
+### mockCockpit
+
+Returns an in-memory mock of the `cockpit` browser global. Stubs out `cockpit.spawn`, `cockpit.file`, `cockpit.http`, and channel creation so tests never attempt real system calls.
+
+Set it up in your test file:
+
+```ts
+beforeEach(() => {
+  vi.stubGlobal("cockpit", mockCockpit());
+});
+```
+
+Individual spawn calls can be configured to return specific output or to reject, letting you test both success and error paths.
+
+### mockHttpClient
+
+Returns a mock of the Cockpit HTTP client with configurable per-path responses. Useful for testing components that call `cockpit.http().get(path)`.
+
+```ts
+const client = mockHttpClient({ "/api/status": '{"running": true}' });
+```
+
+`get`, `post`, and `request` are all `vi.fn()` instances, so you can assert call counts and arguments with standard Vitest matchers.
+
+---
+
+## Running tests
+
+```bash
+npm test          # single run
+npm run test:watch  # watch mode
+```

package/docs/wiki/VM-Testing.md

@@ -0,0 +1,99 @@
+# VM Testing
+
+The package ships a QEMU-based VM harness for end-to-end testing against a real Cockpit instance running on a real OS. It spins up cloud VMs (Arch, Debian, Fedora by default), installs Cockpit, and mounts your built plugin via virtfs — no packaging or installation step required.
+
+## Prerequisites
+
+Arch Linux:
+```bash
+sudo pacman -S qemu-full cloud-image-utils wget
+```
+
+KVM access is strongly recommended. Without it the VMs run without hardware acceleration and will be significantly slower.
+
+## How it works
+
+1. A base cloud image is downloaded once per distro and kept on disk
+2. Each VM gets a thin overlay disk so the base image is never modified
+3. cloud-init provisions the VM on first boot: creates a `test` user, installs Cockpit and any plugin-specific packages, and mounts your plugin's `src/` directory read-only into the Cockpit install path via 9p/virtfs
+4. Changes to your built output (`src/main.js`, `src/main.css`) are immediately visible inside the VM without a restart
+
+## Plugin configuration
+
+Each plugin provides `scripts/test-vm.config.sh` to customise the harness:
+
+```bash
+PLUGIN_NAME="cockpit-caddy"
+MOUNT_TAG="cockpit_caddy"
+INSTALL_PATH="/usr/share/cockpit/cockpit-caddy"
+
+extra_packages() {
+  echo "caddy"
+}
+
+extra_runcmd() {
+  echo "  - systemctl enable --now caddy"
+}
+```
+
+## Usage
+
+Add to your plugin's `package.json`:
+```json
+"vm": "node_modules/@rxtx4816/cockpit-plugin-base-react/scripts/test-vm.sh"
+```
+
+Then:
+
+```bash
+npm run build                    # build the plugin first
+npm run vm download arch         # download base image (once)
+npm run vm start arch            # start the VM
+npm run vm wait arch             # block until cloud-init finishes (~2 min first boot)
+# open https://localhost:9090 — login: test / test
+```
+
+After the initial boot, subsequent starts are fast (no re-provisioning unless you `clean`).
+
+## All commands
+
+| Command | Description |
+|---|---|
+| `download [vm\|all]` | Download base cloud images |
+| `build` | Run `npm run build` |
+| `start [vm ...]` | Start VM(s) in background |
+| `wait <vm>` | Block until cloud-init completes |
+| `stop [vm ...]` | Stop VM(s) |
+| `status` | Show all VMs with ports and running state |
+| `ssh <vm>` | Open an SSH session into the VM |
+| `logs <vm>` | Tail the VM serial console |
+| `clean [vm ...]` | Wipe disk and cloud-init state (base image kept) |
+| `rebuild [vm ...]` | `clean` + `start` in one step |
+| `reset [vm ...]` | Remove all VM files including base image |
+
+## Ports
+
+By default the VMs are assigned sequential ports starting from:
+- Cockpit: `9090`, `9091`, `9092` (arch, debian, fedora)
+- SSH: `2220`, `2221`, `2222`
+
+These can be changed in your `test-vm.config.sh` via `SSH_BASE` and `COCKPIT_BASE`.
+
+## Live reload workflow
+
+Because the plugin is mounted via virtfs, you can iterate quickly:
+
+```bash
+npm run watch       # rebuild on source changes
+npm run vm start arch
+npm run vm wait arch
+# reload the browser tab after each rebuild — no VM restart needed
+```
+
+## Environment overrides
+
+| Variable | Default | Description |
+|---|---|---|
+| `VM_MEM` | `1024` | Memory per VM in MB |
+| `VM_CPUS` | `2` | vCPU count |
+| `VM_DISK_SIZE` | `12G` | Overlay disk size |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rxtx4816/cockpit-plugin-base-react",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Shared infrastructure for Cockpit plugins: i18n, dark theme, test setup, config presets, CI/CD workflows, and QEMU VM harness",
   "type": "module",
   "author": "RXTX4816",
@@ -60,20 +60,24 @@
       "default": "./eslint.config.base.js"
     },
     "./vitest.config.base": {
-      "default": "./vitest.config.base.ts"
+      "default": "./vitest.config.base.js"
     }
   },
   "files": [
+    "LICENSE",
+    "README.md",
+    "docs/",
     "src/",
     "scripts/",
     "tsconfig.base.json",
     "eslint.config.base.js",
-    "vitest.config.base.ts"
+    "vitest.config.base.js"
   ],
   "bin": {
     "cockpit-test-vm": "./scripts/test-vm.sh"
   },
   "scripts": {
+    "lint": "eslint src/",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest"

package/src/cockpit.d.ts

@@ -1,5 +1,6 @@
 // Ambient type declarations for the Cockpit browser global.
 // Superset covering cockpit-caddy and cockpit-compose usage patterns.
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
 /// <reference path="./css.d.ts" />
 
 declare interface CockpitProcess extends Promise<string> {

package/src/systemd/useServiceStatus.test.ts

@@ -1,5 +1,5 @@
 import { renderHook, act, waitFor } from "@testing-library/react";
-import { vi, describe, it, expect, beforeEach, afterEach } from "vitest";
+import { vi, describe, it, expect, beforeEach } from "vitest";
 import { useServiceStatus } from "./useServiceStatus";
 
 const mockSpawn = vi.fn();

package/{vitest.config.base.ts → vitest.config.base.js}

@@ -1,22 +1,13 @@
 import { defineConfig } from "vitest/config";
-import type { TestUserConfig } from "vitest/config";
 
-type TestConfig = TestUserConfig;
-
-export function createVitestConfig(overrides: TestConfig = {}) {
+export function createVitestConfig(overrides = {}) {
   const { coverage: coverageOverrides, setupFiles: extraSetupFiles, ...rest } = overrides;
 
   return defineConfig({
     server: {
-      // Allow Vite's dev server to serve files from symlinked file: packages
-      // that live outside the consuming project's root directory.
       fs: { allow: [".."] },
     },
     resolve: {
-      // Deduplicate packages that must be singletons when cockpit-plugin-base-react
-      // is installed as a file: link (symlink) — without this, the linked
-      // package resolves these from its own node_modules and React / i18next
-      // end up with two separate instances, breaking hooks and translations.
       dedupe: ["react", "react-dom", "i18next", "react-i18next", "@patternfly/react-core", "@patternfly/react-icons"],
     },
     test: {