Files
Netcatty/application/state/useSystemManagerBackend.ts
T
61839acaca [Feature] System 面板增加 GPU / NPU 占用监控 (#2561) (#2768)
* feat(system): add GPU/NPU monitor tab when accelerators are detected

Probe nvidia-smi and npu-smi during System capabilities checks and show a
GPU sub-tab with utilization, memory/HBM, temperature, power, and compute
processes. Reuses the existing SSH exec + parse pattern (same approach as
open-source remote GPU monitors) without new dependencies.

Related to #2561

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

* fix(system): address GPU monitor Bugbot findings

- Use PowerShell nvidia-smi collector for local Windows sessions
- Keep GPU tab in loading state while listAccelerators is pending
- Render compute processes even when device list is empty
- Stop treating Ascend HBM usage rate (%) as megabytes

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

* fix(system): address Codex GPU collector review findings

- Wrap POSIX accelerator script with JSON.stringify so nested sed
  quotes cannot break outer sh -c
- Parse Ascend proc-mem whitespace-delimited table rows

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

* fix(system): show unknown GPU util/memory as -- not 0%

ResourceBar now treats null/undefined as unavailable, and the GPU
device cards pass through null metrics instead of coalescing to 0.

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

---------

Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>
2026-08-06 11:44:08 +08:00

210 lines
6.8 KiB
TypeScript

import { useCallback, useMemo } from 'react';
import type { DockerContainerAction, DockerImageManageAction, TmuxManageAction } from '../../domain/systemManager/types';
import { netcattyBridge } from '../../infrastructure/services/netcattyBridge';
export function useSystemManagerBackend() {
const probeSystemCapabilities = useCallback(async (sessionId: string) => {
const bridge = netcattyBridge.get();
if (!bridge?.probeSystemCapabilities) {
return { success: false as const, error: 'probeSystemCapabilities unavailable' };
}
return bridge.probeSystemCapabilities(sessionId);
}, []);
const listSystemProcesses = useCallback(async (sessionId: string) => {
const bridge = netcattyBridge.get();
if (!bridge?.listSystemProcesses) {
return { success: false as const, error: 'listSystemProcesses unavailable' };
}
return bridge.listSystemProcesses(sessionId);
}, []);
const signalSystemProcess = useCallback(async (options: {
sessionId: string;
pid: number;
signal?: string;
nice?: number;
}) => {
const bridge = netcattyBridge.get();
if (!bridge?.signalSystemProcess) {
return { success: false as const, error: 'signalSystemProcess unavailable' };
}
return bridge.signalSystemProcess(options);
}, []);
const listTmuxSessions = useCallback(async (sessionId: string) => {
const bridge = netcattyBridge.get();
if (!bridge?.listTmuxSessions) {
return { success: false as const, error: 'listTmuxSessions unavailable' };
}
return bridge.listTmuxSessions(sessionId);
}, []);
const createTmuxSession = useCallback(async (options: {
sessionId: string;
name: string;
command?: string;
}) => {
const bridge = netcattyBridge.get();
if (!bridge?.createTmuxSession) {
return { success: false as const, error: 'createTmuxSession unavailable' };
}
return bridge.createTmuxSession(options);
}, []);
const listTmuxWindows = useCallback(async (options: { sessionId: string; sessionName: string }) => {
const bridge = netcattyBridge.get();
if (!bridge?.listTmuxWindows) {
return { success: false as const, error: 'listTmuxWindows unavailable' };
}
return bridge.listTmuxWindows(options);
}, []);
const listTmuxPanes = useCallback(async (options: {
sessionId: string;
sessionName: string;
windowIndex: number;
}) => {
const bridge = netcattyBridge.get();
if (!bridge?.listTmuxPanes) {
return { success: false as const, error: 'listTmuxPanes unavailable' };
}
return bridge.listTmuxPanes(options);
}, []);
const listTmuxClients = useCallback(async (options: { sessionId: string; sessionName?: string }) => {
const bridge = netcattyBridge.get();
if (!bridge?.listTmuxClients) {
return { success: false as const, error: 'listTmuxClients unavailable' };
}
return bridge.listTmuxClients(options);
}, []);
const tmuxAction = useCallback(async (options: { sessionId: string } & TmuxManageAction) => {
const bridge = netcattyBridge.get();
if (!bridge?.tmuxAction) {
return { success: false as const, error: 'tmuxAction unavailable' };
}
return bridge.tmuxAction(options);
}, []);
const listDockerContainers = useCallback(async (sessionId: string) => {
const bridge = netcattyBridge.get();
if (!bridge?.listDockerContainers) {
return { success: false as const, error: 'listDockerContainers unavailable' };
}
return bridge.listDockerContainers(sessionId);
}, []);
const listDockerImages = useCallback(async (sessionId: string) => {
const bridge = netcattyBridge.get();
if (!bridge?.listDockerImages) {
return { success: false as const, error: 'listDockerImages unavailable' };
}
return bridge.listDockerImages(sessionId);
}, []);
const getDockerStats = useCallback(async (options: { sessionId: string; ids?: string[] }) => {
const bridge = netcattyBridge.get();
if (!bridge?.getDockerStats) {
return { success: false as const, error: 'getDockerStats unavailable' };
}
return bridge.getDockerStats(options);
}, []);
const listAccelerators = useCallback(async (sessionId: string) => {
const bridge = netcattyBridge.get();
if (!bridge?.listAccelerators) {
return { success: false as const, error: 'listAccelerators unavailable' };
}
return bridge.listAccelerators(sessionId);
}, []);
const dockerInspect = useCallback(async (options: { sessionId: string; containerId: string }) => {
const bridge = netcattyBridge.get();
if (!bridge?.dockerInspect) {
return { success: false as const, error: 'dockerInspect unavailable' };
}
return bridge.dockerInspect(options);
}, []);
const dockerImageInspect = useCallback(async (options: { sessionId: string; imageId: string }) => {
const bridge = netcattyBridge.get();
if (!bridge?.dockerImageInspect) {
return { success: false as const, error: 'dockerImageInspect unavailable' };
}
return bridge.dockerImageInspect(options);
}, []);
const dockerAction = useCallback(async (options: {
sessionId: string;
containerId: string;
action: DockerContainerAction;
newName?: string;
}) => {
const bridge = netcattyBridge.get();
if (!bridge?.dockerAction) {
return { success: false as const, error: 'dockerAction unavailable' };
}
return bridge.dockerAction(options);
}, []);
const dockerImageAction = useCallback(async (options: { sessionId: string } & DockerImageManageAction) => {
const bridge = netcattyBridge.get();
if (!bridge?.dockerImageAction) {
return { success: false as const, error: 'dockerImageAction unavailable' };
}
return bridge.dockerImageAction(options);
}, []);
const openTerminalPopup = useCallback(async (
payload: Parameters<NonNullable<NetcattyBridge['openTerminalPopup']>>[0],
) => {
const bridge = netcattyBridge.get();
if (!bridge?.openTerminalPopup) {
return { success: false as const, error: 'openTerminalPopup unavailable' };
}
return bridge.openTerminalPopup(payload);
}, []);
return useMemo(() => ({
probeSystemCapabilities,
listSystemProcesses,
signalSystemProcess,
listTmuxSessions,
createTmuxSession,
listTmuxWindows,
listTmuxPanes,
listTmuxClients,
tmuxAction,
listDockerContainers,
listDockerImages,
getDockerStats,
listAccelerators,
dockerInspect,
dockerImageInspect,
dockerAction,
dockerImageAction,
openTerminalPopup,
}), [
probeSystemCapabilities,
listSystemProcesses,
signalSystemProcess,
listTmuxSessions,
createTmuxSession,
listTmuxWindows,
listTmuxPanes,
listTmuxClients,
tmuxAction,
listDockerContainers,
listDockerImages,
getDockerStats,
listAccelerators,
dockerInspect,
dockerImageInspect,
dockerAction,
dockerImageAction,
openTerminalPopup,
]);
}