[Init] Initial commit - NetMesh terminal manager

application/state/codingCliSessionSignalController.ts

@@ -0,0 +1,236 @@
+import { useEffect, useRef } from 'react';
+import { matchCodingCliProviderFromCommand } from '../../domain/codingCliProviderMatch';
+import {
+  createCodingCliOutputScanner,
+  type CodingCliOutputScanner,
+} from '../../domain/codingCliOutputDetect';
+import type { CodingCliProviderId } from '../../domain/codingCliProviders';
+import {
+  inferCodingCliProviderFromTitleSignals,
+  shouldClearCodingCliProviderForTitle,
+} from '../../domain/codingCliTitleParse';
+import type { DynamicTabTitleMode } from '../../domain/models';
+import {
+  resolveCodingCliProviderIconUpdate,
+  shouldUpdateCodingCliTabIcon,
+} from '../../domain/sessionTabTitle';
+
+type CodingCliIconSession = {
+  id: string;
+  codingCliProviderId?: CodingCliProviderId;
+};
+
+export type CodingCliSessionSignalControllerDeps = {
+  getDynamicTabTitleMode: () => DynamicTabTitleMode;
+  getSession: (sessionId: string) => CodingCliIconSession | undefined;
+  onUpdateSessionCodingCliProvider?: (
+    sessionId: string,
+    providerId: CodingCliProviderId | null,
+  ) => void;
+  onUpdateSessionDynamicTitle?: (sessionId: string, title: string | null) => void;
+};
+
+export type CodingCliSessionSignalController = {
+  handleDynamicTabTitleModeChange: (mode: DynamicTabTitleMode) => void;
+  handleCommandSubmitted: (sessionId: string, commandLine: string) => void;
+  handleTerminalOutput: (sessionId: string, chunk: string) => void;
+  handleTerminalTitleChange: (sessionId: string, title: string | null) => void;
+  forgetSession: (sessionId: string) => void;
+};
+
+type UseCodingCliSessionSignalsOptions = Omit<
+  CodingCliSessionSignalControllerDeps,
+  'getDynamicTabTitleMode'
+> & {
+  dynamicTabTitleMode: DynamicTabTitleMode;
+  sessionIds: readonly string[];
+};
+
+export function createCodingCliSessionSignalController(
+  deps: CodingCliSessionSignalControllerDeps,
+): CodingCliSessionSignalController {
+  const outputScanners = new Map<string, CodingCliOutputScanner>();
+  const outputScanDisabled = new Set<string>();
+  // TerminalLayer may memo-skip title/provider-only session updates, so the
+  // controller keeps its own provider memory instead of trusting a stale
+  // sessionsRef from a skipped render.
+  const knownProviderBySession = new Map<string, CodingCliProviderId | null>();
+  let observedDynamicTabTitleMode = deps.getDynamicTabTitleMode();
+
+  const resolveCurrentProviderId = (sessionId: string): CodingCliProviderId | null | undefined => {
+    if (knownProviderBySession.has(sessionId)) {
+      return knownProviderBySession.get(sessionId);
+    }
+    return deps.getSession(sessionId)?.codingCliProviderId;
+  };
+
+  const handleDynamicTabTitleModeChange = (mode: DynamicTabTitleMode) => {
+    if (mode === observedDynamicTabTitleMode) return;
+    const previousMode = observedDynamicTabTitleMode;
+    observedDynamicTabTitleMode = mode;
+    // agent <-> all both keep live detection on; clearing would re-arm
+    // exhausted startup scans and mis-tag ordinary mid-session output.
+    if (previousMode === 'off' || mode === 'off') {
+      outputScanners.clear();
+      outputScanDisabled.clear();
+    }
+  };
+
+  const getCurrentDynamicTabTitleMode = () => {
+    const mode = deps.getDynamicTabTitleMode();
+    handleDynamicTabTitleModeChange(mode);
+    return mode;
+  };
+
+  const applyProvider = (sessionId: string, providerId: CodingCliProviderId | null) => {
+    const session = deps.getSession(sessionId);
+    if (!session && !knownProviderBySession.has(sessionId)) return;
+    const nextProviderId = resolveCodingCliProviderIconUpdate({
+      dynamicTabTitleMode: getCurrentDynamicTabTitleMode(),
+      currentProviderId: resolveCurrentProviderId(sessionId),
+      nextProviderId: providerId,
+    });
+    if (nextProviderId === undefined) return;
+    knownProviderBySession.set(sessionId, nextProviderId);
+    deps.onUpdateSessionCodingCliProvider?.(sessionId, nextProviderId);
+  };
+
+  const handleCommandSubmitted = (sessionId: string, commandLine: string) => {
+    if (!shouldUpdateCodingCliTabIcon(getCurrentDynamicTabTitleMode())) return;
+    const provider = matchCodingCliProviderFromCommand(commandLine);
+    if (!provider) return;
+    outputScanners.delete(sessionId);
+    outputScanDisabled.delete(sessionId);
+    applyProvider(sessionId, provider.id);
+  };
+
+  const handleTerminalTitleChange = (sessionId: string, title: string | null) => {
+    const session = deps.getSession(sessionId);
+    if (!session && !knownProviderBySession.has(sessionId)) return;
+    const dynamicTabTitleMode = getCurrentDynamicTabTitleMode();
+    const trimmedTitle = title?.trim();
+    const providerId = trimmedTitle
+      ? inferCodingCliProviderFromTitleSignals(trimmedTitle)
+      : undefined;
+    const currentProviderId = resolveCurrentProviderId(sessionId);
+    const shouldStoreDynamicTitle =
+      dynamicTabTitleMode === 'all'
+      || (
+        dynamicTabTitleMode === 'agent'
+        && Boolean(currentProviderId || providerId)
+      );
+    deps.onUpdateSessionDynamicTitle?.(sessionId, shouldStoreDynamicTitle ? title : null);
+
+    if (!shouldUpdateCodingCliTabIcon(dynamicTabTitleMode)) return;
+    if (!trimmedTitle) {
+      if (currentProviderId) {
+        outputScanners.delete(sessionId);
+        outputScanDisabled.delete(sessionId);
+        applyProvider(sessionId, null);
+      }
+      return;
+    }
+
+    if (providerId) {
+      if (!currentProviderId || currentProviderId !== providerId) {
+        outputScanners.delete(sessionId);
+        outputScanDisabled.delete(sessionId);
+        applyProvider(sessionId, providerId);
+      }
+      return;
+    }
+
+    if (
+      currentProviderId
+      && shouldClearCodingCliProviderForTitle(trimmedTitle, currentProviderId)
+    ) {
+      outputScanners.delete(sessionId);
+      outputScanDisabled.delete(sessionId);
+      applyProvider(sessionId, null);
+    }
+  };
+
+  const handleTerminalOutput = (sessionId: string, chunk: string) => {
+    const dynamicTabTitleMode = getCurrentDynamicTabTitleMode();
+    if (!chunk || outputScanDisabled.has(sessionId)) return;
+    if (!shouldUpdateCodingCliTabIcon(dynamicTabTitleMode)) return;
+
+    const session = deps.getSession(sessionId);
+    if (!session && !knownProviderBySession.has(sessionId)) {
+      outputScanners.delete(sessionId);
+      outputScanDisabled.delete(sessionId);
+      return;
+    }
+    if (resolveCurrentProviderId(sessionId)) return;
+
+    let scanner = outputScanners.get(sessionId);
+    if (!scanner) {
+      scanner = createCodingCliOutputScanner();
+      outputScanners.set(sessionId, scanner);
+    }
+
+    const providerId = scanner.feed(chunk);
+    if (providerId) {
+      applyProvider(sessionId, providerId);
+      return;
+    }
+
+    if (scanner.isExhausted()) {
+      outputScanners.delete(sessionId);
+      outputScanDisabled.add(sessionId);
+    }
+  };
+
+  return {
+    handleDynamicTabTitleModeChange,
+    handleCommandSubmitted,
+    handleTerminalOutput,
+    handleTerminalTitleChange,
+    forgetSession: (sessionId: string) => {
+      outputScanners.delete(sessionId);
+      outputScanDisabled.delete(sessionId);
+      knownProviderBySession.delete(sessionId);
+    },
+  };
+}
+
+export function useCodingCliSessionSignals(
+  options: UseCodingCliSessionSignalsOptions,
+): CodingCliSessionSignalController {
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+
+  const controllerRef = useRef<CodingCliSessionSignalController | null>(null);
+  if (!controllerRef.current) {
+    controllerRef.current = createCodingCliSessionSignalController({
+      getDynamicTabTitleMode: () => optionsRef.current.dynamicTabTitleMode,
+      getSession: (sessionId) => optionsRef.current.getSession(sessionId),
+      onUpdateSessionCodingCliProvider: (sessionId, providerId) => {
+        optionsRef.current.onUpdateSessionCodingCliProvider?.(sessionId, providerId);
+      },
+      onUpdateSessionDynamicTitle: (sessionId, title) => {
+        optionsRef.current.onUpdateSessionDynamicTitle?.(sessionId, title);
+      },
+    });
+  }
+
+  const controller = controllerRef.current;
+  const liveSessionIdsRef = useRef(new Set(options.sessionIds));
+  useEffect(() => {
+    controller.handleDynamicTabTitleModeChange(options.dynamicTabTitleMode);
+  }, [controller, options.dynamicTabTitleMode]);
+  useEffect(() => {
+    const nextSessionIds = new Set(options.sessionIds);
+    for (const sessionId of liveSessionIdsRef.current) {
+      if (!nextSessionIds.has(sessionId)) controller.forgetSession(sessionId);
+    }
+    liveSessionIdsRef.current = nextSessionIds;
+  }, [controller, options.sessionIds]);
+  useEffect(() => () => {
+    for (const sessionId of liveSessionIdsRef.current) {
+      controller.forgetSession(sessionId);
+    }
+  }, [controller]);
+
+  return controller;
+}