[Init] Initial commit - NetMesh terminal manager

application/state/useVaultAgentBridge.ts

@@ -0,0 +1,274 @@
+import { useEffect, useRef } from 'react';
+import { applyGroupDefaults, resolveGroupDefaults } from '../../domain/groupConfig';
+import type { GroupConfig, Host, Identity, KnownHost, ManagedSource, PortForwardingRule, ProxyProfile, Snippet, SSHKey, TerminalSession, TerminalSettings, VaultNote } from '../../domain/models';
+import { materializeHostProxyProfile } from '../../domain/proxyProfiles';
+import {
+  handleVaultAgentOp,
+  registerVaultAgentHandler,
+  setupVaultAgentBridge,
+  type VaultAgentApiDeps,
+} from '../../infrastructure/ai/vaultAgentBridgeClient';
+import {
+  clearRememberedKeyPassphrases,
+  readRememberedKeyPassphrases,
+  rememberImportedKeyPassphrase,
+  rememberKeyPassphrase,
+  resolveDefaultKeyPassphraseAliases,
+} from '../defaultKeyPassphrases';
+import { getNotesActions, getNotesSnapshot, subscribeNotes } from './notesStore';
+import type {
+  VaultGroupMutationResult,
+  VaultGroupMutationState,
+} from '../../domain/vaultGroupMutation';
+
+export interface UseVaultAgentBridgeInput {
+  hosts: Host[];
+  snippets: Snippet[];
+  portForwardingRules: PortForwardingRule[];
+  keys: SSHKey[];
+  identities: Identity[];
+  knownHosts: KnownHost[];
+  proxyProfiles: ProxyProfile[];
+  managedSources: ManagedSource[];
+  terminalSettings?: Pick<TerminalSettings, 'keepaliveInterval' | 'keepaliveCountMax'>;
+  updateHosts: (hosts: Host[]) => void;
+  updateKeys: (keys: SSHKey[]) => Promise<unknown> | unknown;
+  updateSnippets: (
+    snippets: Snippet[] | ((current: Snippet[]) => Snippet[]),
+  ) => void;
+  customGroups: string[];
+  updateCustomGroups: (groups: string[]) => void;
+  groupConfigs: GroupConfig[];
+  updateGroupConfigs: (configs: GroupConfig[]) => void;
+  updateManagedSources: (sources: ManagedSource[]) => void;
+  commitVaultGroupMutation: (
+    mutate: (current: VaultGroupMutationState) => VaultGroupMutationResult,
+  ) => Promise<VaultGroupMutationResult | { ok: false; superseded: true }>;
+  updatePortForwardingRules: (rules: PortForwardingRule[]) => void;
+  /** Optional override; defaults to notesStore so App need not subscribe to notes. */
+  notes?: VaultNote[];
+  /** Optional override; defaults to notesStore actions. */
+  updateNotes?: (notes: VaultNote[]) => void;
+  startTunnel: VaultAgentApiDeps['startTunnel'];
+  stopTunnel: VaultAgentApiDeps['stopTunnel'];
+  stopRuleTunnels: VaultAgentApiDeps['stopRuleTunnels'];
+  openHost?: VaultAgentApiDeps['openHost'];
+  closeSession?: VaultAgentApiDeps['closeSession'];
+  getScriptSessionMeta?: (sessionId: string) => Pick<TerminalSession, 'status' | 'customName' | 'hostLabel' | 'hostname' | 'username'> | undefined;
+}
+
+type VaultAgentSnapshot = {
+  hosts: Host[];
+  keys: SSHKey[];
+  notes: VaultNote[];
+  snippets: Snippet[];
+  customGroups: string[];
+  groupConfigs: GroupConfig[];
+  portForwardingRules: PortForwardingRule[];
+  managedSources: ManagedSource[];
+};
+
+const selectVaultAgentSnapshot = (input: UseVaultAgentBridgeInput): VaultAgentSnapshot => ({
+  hosts: input.hosts,
+  keys: input.keys,
+  notes: input.notes ?? (getNotesSnapshot().notes as VaultNote[]),
+  snippets: input.snippets,
+  customGroups: input.customGroups,
+  groupConfigs: input.groupConfigs,
+  portForwardingRules: input.portForwardingRules,
+  managedSources: input.managedSources,
+});
+
+/** Resolve notes for agent ops: live store wins when App omitted the prop. */
+export function resolveVaultAgentNotes(
+  notesOverride: VaultNote[] | undefined,
+  snapshotNotes: VaultNote[],
+): VaultNote[] {
+  return notesOverride !== undefined
+    ? snapshotNotes
+    : (getNotesSnapshot().notes as VaultNote[]);
+}
+
+export const haveSameVaultAgentSnapshot = (
+  left: VaultAgentSnapshot,
+  right: VaultAgentSnapshot,
+): boolean => (Object.keys(left) as Array<keyof VaultAgentSnapshot>)
+  .every((key) => left[key] === right[key]);
+
+export function resolveVaultAgentEffectiveHost(
+  host: Host,
+  groupConfigs: GroupConfig[],
+  proxyProfiles: ProxyProfile[],
+): Host {
+  const validProxyProfileIds = new Set(proxyProfiles.map((profile) => profile.id));
+  const withGroupDefaults = host.group
+    ? applyGroupDefaults(
+        host,
+        resolveGroupDefaults(host.group, groupConfigs, { validProxyProfileIds }),
+        { validProxyProfileIds },
+      )
+    : applyGroupDefaults(host, {}, { validProxyProfileIds });
+  return materializeHostProxyProfile(withGroupDefaults, proxyProfiles);
+}
+
+export function useVaultAgentBridge(input: UseVaultAgentBridgeInput): void {
+  const inputRef = useRef(input);
+  inputRef.current = input;
+
+  const selectedSnapshot = selectVaultAgentSnapshot(input);
+  const vaultSnapshotRef = useRef<VaultAgentSnapshot>(selectedSnapshot);
+  const lastSyncedVaultInputRef = useRef<VaultAgentSnapshot>(selectedSnapshot);
+
+  if (!haveSameVaultAgentSnapshot(selectedSnapshot, lastSyncedVaultInputRef.current)) {
+    vaultSnapshotRef.current = selectedSnapshot;
+    lastSyncedVaultInputRef.current = selectedSnapshot;
+  }
+
+  // Keep notes fresh without forcing App to re-render on every note edit.
+  // Write in place: this object is also `lastSyncedVaultInputRef.current`, and
+  // the agent op handlers below rely on that aliasing so their writes survive
+  // the render-time comparison above. Replacing the object would break it.
+  useEffect(() => {
+    if (input.notes !== undefined) return;
+    const syncNotes = () => {
+      vaultSnapshotRef.current.notes = getNotesSnapshot().notes as VaultNote[];
+    };
+    syncNotes();
+    return subscribeNotes(syncNotes);
+  }, [input.notes]);
+
+  useEffect(() => {
+    registerVaultAgentHandler(async (op, params) => {
+      const current = inputRef.current;
+      const applyUpdateNotes = current.updateNotes
+        ?? getNotesActions()?.updateNotes
+        ?? ((notes: VaultNote[]) => {
+          console.warn('[useVaultAgentBridge] updateNotes unavailable');
+          void notes;
+        });
+      return handleVaultAgentOp(op, params, {
+        getHosts: () => vaultSnapshotRef.current.hosts,
+        getNotes: () => resolveVaultAgentNotes(
+          current.notes,
+          vaultSnapshotRef.current.notes,
+        ),
+        getCustomGroups: () => vaultSnapshotRef.current.customGroups,
+        getGroupConfigs: () => vaultSnapshotRef.current.groupConfigs,
+        getPortForwardingRules: () => vaultSnapshotRef.current.portForwardingRules,
+        getManagedSources: () => vaultSnapshotRef.current.managedSources,
+        snippets: vaultSnapshotRef.current.snippets,
+        keys: vaultSnapshotRef.current.keys,
+        identities: current.identities,
+        knownHosts: current.knownHosts,
+        proxyProfiles: current.proxyProfiles,
+        terminalSettings: current.terminalSettings,
+        resolveEffectiveHost: (host) => resolveVaultAgentEffectiveHost(
+          host,
+          vaultSnapshotRef.current.groupConfigs,
+          current.proxyProfiles,
+        ),
+        updateHostNotes: (hostId, notes) => {
+          const nextHosts = vaultSnapshotRef.current.hosts.map((host) => (
+            host.id === hostId ? { ...host, notes } : host
+          ));
+          vaultSnapshotRef.current.hosts = nextHosts;
+          current.updateHosts(nextHosts);
+        },
+        updateCustomGroups: (groups) => {
+          vaultSnapshotRef.current.customGroups = groups;
+          current.updateCustomGroups(groups);
+        },
+        updateGroupConfigs: (configs) => {
+          vaultSnapshotRef.current.groupConfigs = configs;
+          current.updateGroupConfigs(configs);
+        },
+        updatePortForwardingRules: (rules) => {
+          vaultSnapshotRef.current.portForwardingRules = rules;
+          current.updatePortForwardingRules(rules);
+        },
+        updateManagedSources: (sources) => {
+          vaultSnapshotRef.current.managedSources = sources;
+          current.updateManagedSources(sources);
+        },
+        updateHosts: (hosts) => {
+          vaultSnapshotRef.current.hosts = hosts;
+          current.updateHosts(hosts);
+        },
+        commitVaultGroupMutation: async (mutate) => {
+          const result = await current.commitVaultGroupMutation(mutate);
+          if (result.ok) {
+            vaultSnapshotRef.current.customGroups = result.state.groups;
+            vaultSnapshotRef.current.groupConfigs = result.state.configs;
+            vaultSnapshotRef.current.hosts = result.state.hosts;
+            vaultSnapshotRef.current.managedSources = result.state.managedSources;
+            vaultSnapshotRef.current.snippets = result.state.snippets;
+          }
+          return result;
+        },
+        saveKeyPassphrase: (keyPath, passphrase) => rememberKeyPassphrase({
+          keyPath,
+          passphrase,
+          keys: vaultSnapshotRef.current.keys,
+          getKeys: () => vaultSnapshotRef.current.keys,
+          updateKeys: current.updateKeys,
+          setCurrentKeys: (keys) => {
+            vaultSnapshotRef.current.keys = keys;
+          },
+        }),
+        saveImportedKeyPassphrase: (keyPath, passphrase) => rememberImportedKeyPassphrase({
+          keyPath,
+          passphrase,
+          keys: vaultSnapshotRef.current.keys,
+          getKeys: () => vaultSnapshotRef.current.keys,
+          updateKeys: current.updateKeys,
+          setCurrentKeys: (keys) => {
+            vaultSnapshotRef.current.keys = keys;
+          },
+        }),
+        resolveKeyPassphraseAliases: resolveDefaultKeyPassphraseAliases,
+        readKeyPassphrases: (keyPath) => readRememberedKeyPassphrases(
+          keyPath,
+          vaultSnapshotRef.current.keys,
+        ),
+        removeKeyPassphrases: (keyPaths) => clearRememberedKeyPassphrases({
+          keyPaths,
+          getKeys: () => vaultSnapshotRef.current.keys,
+          setCurrentKeys: (keys) => {
+            vaultSnapshotRef.current.keys = keys;
+          },
+          updateKeys: current.updateKeys,
+        }),
+        updateNotes: (notes) => {
+          vaultSnapshotRef.current.notes = notes;
+          applyUpdateNotes(notes);
+        },
+        updateSnippets: (snippetUpdate) => {
+          vaultSnapshotRef.current.snippets = typeof snippetUpdate === 'function'
+            ? snippetUpdate(vaultSnapshotRef.current.snippets)
+            : snippetUpdate;
+          current.updateSnippets(snippetUpdate);
+        },
+        startTunnel: current.startTunnel,
+        stopTunnel: current.stopTunnel,
+        stopRuleTunnels: current.stopRuleTunnels,
+        openHost: current.openHost
+          ? (host, isExternalMcpCall) => current.openHost!(host, isExternalMcpCall)
+          : undefined,
+        closeSession: current.closeSession
+          ? (sessionId) => current.closeSession!(sessionId)
+          : undefined,
+        getScriptSessionMeta: (sessionId) => {
+          const session = current.getScriptSessionMeta?.(sessionId);
+          if (!session) return undefined;
+          return {
+            connected: session.status === 'connected',
+            name: session.customName || session.hostLabel,
+            hostname: session.hostname,
+            username: session.username,
+          };
+        },
+      });
+    });
+    return setupVaultAgentBridge();
+  }, []);
+}