Files
kandev/apps/web/components/settings/plugins/use-plugin-actions.ts
T
Kandev Agent c53f699714 feat: add plugin system with grpc runtime and native ui plugins
- go plugin backends ship as release tarballs (per-platform binaries, checksums) that
  kandev installs from url/upload or filesystem sideload+sync, then spawns and
  supervises via hashicorp/go-plugin (unix socket / loopback tcp+automtls)
- strict typed grpc contract (kandev.plugin.v1): DeliverEvent/InvokeTool/HandleWebhook
  plus a capability-gated host service (state, secrets, emit); author sdk in
  pkg/pluginsdk; packaging cli in cmd/plugin-pack
- native frontend bundles: window.registerKandevPlugin + registry/host loader with
  dynamic routes, nav items, slots and ws handlers; plugins settings page with
  install dialog, sync button and enable/disable/uninstall
- gated behind the plugins feature flag (prod off, dev/e2e on); covered by unit and
  integration tests plus playwright e2e against a real packaged fixture plugin

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-16 17:55:45 +01:00

209 lines
7.0 KiB
TypeScript

"use client";
import { useState } from "react";
import { toast } from "sonner";
import type { StoreApi } from "zustand";
import { useAppStore, useAppStoreApi } from "@/components/state-provider";
import { useTheme } from "@/components/theme/app-theme";
import {
disablePlugin,
enablePlugin,
installPluginFromUrl,
installPluginUpload,
listPlugins,
syncPlugins,
uninstallPlugin,
} from "@/lib/api/domains/plugins-api";
import { toActivePlugin } from "@/lib/plugins/active-plugin";
import { buildHostApi } from "@/lib/plugins/host-api";
import { loadPlugins, unloadPlugin } from "@/lib/plugins/host";
import { summarizeSyncResult } from "@/lib/plugins/sync-summary";
import type { PluginRecord, PluginStatus, SyncError } from "@/lib/types/plugins";
import type { AppState } from "@/lib/state/store";
function withStatus(plugin: PluginRecord, status: PluginStatus): PluginRecord {
return { ...plugin, status };
}
/** Loads a plugin's UI bundle into the running app, if it declares one. */
async function loadIfActive(
record: PluginRecord,
storeApi: StoreApi<AppState>,
theme: "light" | "dark",
) {
if (record.status !== "active") return;
const active = toActivePlugin(record);
if (!active) return;
await loadPlugins([active], (pluginId) => buildHostApi(pluginId, storeApi, theme));
}
/**
* Enable/disable action wiring, per task-20's output contract: enabling a
* plugin with a UI bundle calls the task-18 runtime `loadPlugins` for just
* that plugin (no full page reload); disabling calls `unloadPlugin` to
* revoke its nav items/routes/slots immediately.
*/
function useEnableDisableActions(upsertPlugin: (p: PluginRecord) => void) {
const storeApi = useAppStoreApi();
const { resolvedTheme } = useTheme();
const [busyId, setBusyId] = useState<string | null>(null);
const handleEnable = async (plugin: PluginRecord) => {
setBusyId(plugin.id);
try {
await enablePlugin(plugin.id);
const updated = withStatus(plugin, "active");
upsertPlugin(updated);
await loadIfActive(updated, storeApi, resolvedTheme);
} catch (err) {
toast.error(err instanceof Error ? err.message : `Failed to enable ${plugin.display_name}`);
} finally {
setBusyId(null);
}
};
const handleDisable = async (plugin: PluginRecord) => {
setBusyId(plugin.id);
try {
await disablePlugin(plugin.id);
unloadPlugin(plugin.id);
upsertPlugin(withStatus(plugin, "disabled"));
} catch (err) {
toast.error(err instanceof Error ? err.message : `Failed to disable ${plugin.display_name}`);
} finally {
setBusyId(null);
}
};
return { busyId, handleEnable, handleDisable };
}
function useUninstallAction(removePlugin: (id: string) => void) {
const [uninstallTarget, setUninstallTarget] = useState<PluginRecord | null>(null);
const [uninstallBusy, setUninstallBusy] = useState(false);
const confirmUninstall = async () => {
if (!uninstallTarget) return;
const target = uninstallTarget;
setUninstallBusy(true);
try {
await uninstallPlugin(target.id);
unloadPlugin(target.id);
removePlugin(target.id);
setUninstallTarget(null);
} catch (err) {
toast.error(
err instanceof Error ? err.message : `Failed to uninstall ${target.display_name}`,
);
} finally {
setUninstallBusy(false);
}
};
return {
uninstallTarget,
uninstallBusy,
openUninstall: setUninstallTarget,
closeUninstall: () => setUninstallTarget(null),
confirmUninstall,
};
}
/**
* Install-plugin dialog wiring. Install-from-URL and upload share the same
* open/busy/error state and post-install effect: upsert the record into the
* store, and if the backend already brought it up `active` with a UI
* bundle, hot-load it into the running app (no full page reload) — same as
* the enable path.
*/
function useInstallAction(upsertPlugin: (p: PluginRecord) => void) {
const storeApi = useAppStoreApi();
const { resolvedTheme } = useTheme();
const [installOpen, setInstallOpenState] = useState(false);
const [installBusy, setInstallBusy] = useState(false);
const [installError, setInstallError] = useState<string | null>(null);
const closeInstallDialog = () => {
setInstallOpenState(false);
setInstallError(null);
};
const afterInstall = async (record: PluginRecord) => {
upsertPlugin(record);
await loadIfActive(record, storeApi, resolvedTheme);
toast.success(`${record.display_name} installed`);
closeInstallDialog();
};
const runInstall = async (install: () => Promise<PluginRecord>) => {
setInstallBusy(true);
setInstallError(null);
try {
const record = await install();
await afterInstall(record);
} catch (err) {
setInstallError(err instanceof Error ? err.message : "Failed to install plugin");
} finally {
setInstallBusy(false);
}
};
return {
installOpen,
openInstall: () => setInstallOpenState(true),
setInstallOpen: (open: boolean) => (open ? setInstallOpenState(true) : closeInstallDialog()),
installBusy,
installError,
submitInstallUrl: (url: string) => runInstall(() => installPluginFromUrl(url)),
submitInstallFile: (file: File) => runInstall(() => installPluginUpload(file)),
closeInstallDialog,
};
}
/**
* Sync-button wiring: POST /api/plugins/sync, then refresh the plugin list
* via the same GET /api/plugins call usePlugins itself makes on mount, and
* summarize the result as a toast. result.errors are kept in state for an
* inline `plugins-sync-errors` region rather than only living in the toast,
* so they stay visible without depending on toast auto-dismiss timing.
*
* A sync can bring a dropped tarball plugin all the way to `active` with a
* UI bundle, but (unlike install/enable) this does not hot-load it — an
* operator can re-enable it (or reload) to pick up the bundle; wiring a
* silent hot-load here is out of scope for the sync button itself.
*/
function useSyncAction(setPlugins: (plugins: PluginRecord[]) => void) {
const [syncBusy, setSyncBusy] = useState(false);
const [syncErrors, setSyncErrors] = useState<SyncError[]>([]);
const handleSync = async () => {
setSyncBusy(true);
try {
const result = await syncPlugins();
const refreshed = await listPlugins({ cache: "no-store" });
setPlugins(refreshed);
setSyncErrors(result.errors ?? []);
toast.success(summarizeSyncResult(result));
} catch (err) {
toast.error(err instanceof Error ? err.message : "Failed to sync plugins");
} finally {
setSyncBusy(false);
}
};
return { syncBusy, syncErrors, handleSync };
}
export function usePluginActions() {
const upsertPlugin = useAppStore((s) => s.upsertPlugin);
const removePlugin = useAppStore((s) => s.removePlugin);
const setPlugins = useAppStore((s) => s.setPlugins);
const enableDisable = useEnableDisableActions(upsertPlugin);
const uninstall = useUninstallAction(removePlugin);
const install = useInstallAction(upsertPlugin);
const sync = useSyncAction(setPlugins);
return { ...enableDisable, ...uninstall, ...install, ...sync };
}