[Init] Initial commit - NetMesh terminal manager

application/state/usePluginTerminalSessionLifecycle.ts

@@ -0,0 +1,231 @@
+import { useCallback, useEffect, useMemo, useRef } from 'react';
+
+import { getWindowPluginTerminalProviderRegistry } from './pluginTerminalProviderRegistry';
+
+interface PluginTerminalSessionLifecycleOptions {
+  sessionId: string;
+  hostId?: string;
+  workspaceId?: string;
+  protocol?: string;
+  status: 'connecting' | 'connected' | 'disconnected';
+  shellType?: string;
+  initialCwd?: string;
+  ownsBackendLifecycle?: boolean;
+}
+
+export interface PluginTerminalSnapshotState {
+  cwd?: string;
+  title?: string;
+  cols?: number;
+  rows?: number;
+  alternateScreen?: boolean;
+}
+
+type PluginTerminalStatusTransition = Readonly<{
+  snapshotState: PluginTerminalSnapshotState;
+  everConnected: boolean;
+  eventType?: 'connected' | 'reconnected' | 'disconnected';
+  eventDetails?: Readonly<{ exitCode: number }>;
+}>;
+
+export function transitionPluginTerminalConnectionState(
+  snapshotState: PluginTerminalSnapshotState,
+  status: PluginTerminalSessionLifecycleOptions['status'],
+  everConnected: boolean,
+  exitCode?: number,
+): PluginTerminalStatusTransition {
+  const shouldClearConnectionFields = status === 'disconnected' || everConnected;
+  const nextSnapshotState: PluginTerminalSnapshotState = shouldClearConnectionFields
+    ? {
+        ...(snapshotState.cols == null ? {} : { cols: snapshotState.cols }),
+        ...(snapshotState.rows == null ? {} : { rows: snapshotState.rows }),
+      }
+    : { ...snapshotState };
+  if (status === 'connected') {
+    return Object.freeze({
+      snapshotState: nextSnapshotState,
+      everConnected: true,
+      eventType: everConnected ? 'reconnected' : 'connected',
+    });
+  }
+  if (status === 'disconnected') {
+    return Object.freeze({
+      snapshotState: nextSnapshotState,
+      everConnected,
+      eventType: 'disconnected',
+      ...(exitCode === undefined ? {} : { eventDetails: Object.freeze({ exitCode }) }),
+    });
+  }
+  return Object.freeze({
+    snapshotState: nextSnapshotState,
+    everConnected,
+  });
+}
+
+export function normalizePluginTerminalProtocol(
+  protocol: string | undefined,
+): NetcattyTerminalSessionSnapshot['protocol'] {
+  const normalized = protocol?.trim();
+  return normalized || 'ssh';
+}
+
+export function shouldPublishPluginTerminalSessionMountLifecycle(
+  attachExistingSession: boolean,
+): boolean {
+  return !attachExistingSession;
+}
+
+export function beginPluginTerminalSessionMountLifecycle(
+  ownsBackendSessionMount: boolean,
+  publishCreated: () => void,
+  disposeBackendSession: () => void,
+): (() => void) | undefined {
+  if (!ownsBackendSessionMount) return undefined;
+  publishCreated();
+  return disposeBackendSession;
+}
+
+export function ownsPluginTerminalBackendLifecycle(value: boolean | undefined): boolean {
+  return value !== false;
+}
+
+const BACKEND_LIFECYCLE_EVENTS = new Set<NetcattyTerminalSessionEvent['type']>([
+  'created', 'connected', 'reconnected', 'disconnected', 'disposed',
+]);
+
+export function shouldPublishPluginTerminalEvent(
+  type: NetcattyTerminalSessionEvent['type'],
+  ownsBackendLifecycle: boolean | undefined,
+): boolean {
+  return ownsPluginTerminalBackendLifecycle(ownsBackendLifecycle)
+    || !BACKEND_LIFECYCLE_EVENTS.has(type);
+}
+
+function normalizeShellType(shellType: string | undefined): NetcattyTerminalSessionSnapshot['shellType'] | undefined {
+  if (shellType === 'posix' || shellType === 'fish' || shellType === 'powershell' || shellType === 'cmd') {
+    return shellType;
+  }
+  return shellType ? 'unknown' : undefined;
+}
+
+export function usePluginTerminalSessionLifecycle(options: PluginTerminalSessionLifecycleOptions) {
+  const registry = getWindowPluginTerminalProviderRegistry();
+  const metadataRef = useRef(options);
+  metadataRef.current = options;
+  const snapshotStateRef = useRef<PluginTerminalSnapshotState>({ cwd: options.initialCwd });
+  const everConnectedRef = useRef(false);
+  const exitDisconnectPublishedRef = useRef(false);
+
+  const snapshot = useCallback((): NetcattyTerminalSessionSnapshot => {
+    const metadata = metadataRef.current;
+    const state = snapshotStateRef.current;
+    const shellType = normalizeShellType(metadata.shellType);
+    return {
+      sessionId: metadata.sessionId,
+      ...(metadata.hostId ? { hostId: metadata.hostId } : {}),
+      ...(metadata.workspaceId ? { workspaceId: metadata.workspaceId } : {}),
+      protocol: normalizePluginTerminalProtocol(metadata.protocol),
+      status: metadata.status,
+      ...(state.cwd ? { cwd: state.cwd } : {}),
+      ...(state.title ? { title: state.title } : {}),
+      ...(shellType ? { shellType } : {}),
+      ...(state.cols == null ? {} : { cols: state.cols }),
+      ...(state.rows == null ? {} : { rows: state.rows }),
+      ...(state.alternateScreen == null ? {} : { alternateScreen: state.alternateScreen }),
+    };
+  }, []);
+
+  const publish = useCallback((
+    type: NetcattyTerminalSessionEvent['type'],
+    details: { exitCode?: number } = {},
+    sessionOverrides: Partial<NetcattyTerminalSessionSnapshot> = {},
+  ) => {
+    if (!registry) return;
+    if (!shouldPublishPluginTerminalEvent(type, metadataRef.current.ownsBackendLifecycle)) return;
+    void registry.publishSessionEvent({
+      type,
+      session: { ...snapshot(), ...sessionOverrides },
+      ...details,
+    }).catch(() => {});
+  }, [registry, snapshot]);
+
+  useEffect(() => {
+    return beginPluginTerminalSessionMountLifecycle(
+      ownsPluginTerminalBackendLifecycle(options.ownsBackendLifecycle),
+      () => publish('created'),
+      () => {
+        publish('disposed');
+        registry?.cancelSession(metadataRef.current.sessionId);
+      },
+    );
+  }, [options.ownsBackendLifecycle, publish, registry]);
+
+  useEffect(() => {
+    const transition = transitionPluginTerminalConnectionState(
+      snapshotStateRef.current,
+      options.status,
+      everConnectedRef.current,
+    );
+    snapshotStateRef.current = transition.snapshotState;
+    everConnectedRef.current = transition.everConnected;
+    if (transition.eventType === 'disconnected' && exitDisconnectPublishedRef.current) {
+      exitDisconnectPublishedRef.current = false;
+      return;
+    }
+    if (options.status !== 'disconnected') exitDisconnectPublishedRef.current = false;
+    if (transition.eventType) publish(transition.eventType);
+  }, [options.status, publish]);
+
+  const onSessionExited = useCallback((exitCode?: number) => {
+    const transition = transitionPluginTerminalConnectionState(
+      snapshotStateRef.current,
+      'disconnected',
+      everConnectedRef.current,
+      exitCode,
+    );
+    snapshotStateRef.current = transition.snapshotState;
+    everConnectedRef.current = transition.everConnected;
+    exitDisconnectPublishedRef.current = true;
+    publish('disconnected', transition.eventDetails, { status: 'disconnected' });
+  }, [publish]);
+
+  const onCwdChanged = useCallback((cwd: string | null) => {
+    snapshotStateRef.current.cwd = cwd || undefined;
+    publish('cwdChanged');
+  }, [publish]);
+
+  const onTitleChanged = useCallback((title: string | null) => {
+    snapshotStateRef.current.title = title || undefined;
+    publish('titleChanged');
+  }, [publish]);
+
+  const onResized = useCallback((cols: number, rows: number) => {
+    snapshotStateRef.current.cols = cols;
+    snapshotStateRef.current.rows = rows;
+    publish('resized');
+  }, [publish]);
+
+  const onAlternateScreenChanged = useCallback((alternateScreen: boolean) => {
+    if (snapshotStateRef.current.alternateScreen === alternateScreen) return;
+    snapshotStateRef.current.alternateScreen = alternateScreen;
+    publish('alternateScreenChanged');
+  }, [publish]);
+
+  const onCommandSubmitted = useCallback(() => {
+    publish('commandSubmitted');
+  }, [publish]);
+
+  const onCommandCompleted = useCallback(() => {
+    publish('commandCompleted');
+  }, [publish]);
+
+  return useMemo(() => ({
+    onAlternateScreenChanged,
+    onCommandCompleted,
+    onCommandSubmitted,
+    onCwdChanged,
+    onResized,
+    onSessionExited,
+    onTitleChanged,
+  }), [onAlternateScreenChanged, onCommandCompleted, onCommandSubmitted, onCwdChanged, onResized, onSessionExited, onTitleChanged]);
+}