@jcjeon/integration-cli 0.2.0

package/apps/web/src/features/chat/hooks/useCodexSessions.ts

@@ -0,0 +1,275 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import { io, type Socket } from "socket.io-client";
+
+import { CODEX_WS_NAMESPACE, SERVER_URL } from "@/lib/constants";
+import {
+  createCodexSession as apiCreateSession,
+  deleteCodexSession,
+  fetchConversations,
+  fetchDBSessions,
+  saveCodexConversation,
+  updateSessionTitle,
+} from "../api/sessions.api";
+import type { DBConversation, SessionInfo } from "../api/sessions.api";
+import type { AgentModelSettings } from "../lib/agentModelOptions";
+import type { ChatMessage, ResultMeta, SessionState } from "./useClaudeSessions";
+
+export type { SessionInfo };
+
+let msgId = 0;
+const nextId = () => String(++msgId);
+
+function toMessages(convos: DBConversation[]): ChatMessage[] {
+  return convos.map((c) => ({
+    id: c.id,
+    role: (c.type === "user_message" ? "user" : "assistant") as ChatMessage["role"],
+    content: c.content,
+    createdAt: new Date(c.createdAt),
+  }));
+}
+
+export function useCodexSessions() {
+  const socketRef = useRef<Socket | null>(null);
+  const [connectionStatus, setConnectionStatus] = useState<"disconnected" | "connecting" | "connected">("disconnected");
+  const [sessions, setSessions] = useState<SessionState[]>([]);
+  const [selectedSessionId, setSelectedSessionId] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  const streamingRef = useRef<Record<string, string>>({});
+  const pendingPromptIdRef = useRef<Record<string, string>>({});
+  const pendingUserMsgRef = useRef<Record<string, { promptId: string; content: string }>>({});
+  const loadingSessionsRef = useRef<Set<string>>(new Set());
+
+  const loadSessionsFromDB = useCallback(async () => {
+    try {
+      const dbSessions = await fetchDBSessions("codex");
+      setSessions((prev) => {
+        const existingIds = new Set(prev.map((s) => s.info.id));
+        const newStates: SessionState[] = dbSessions
+          .filter((s) => !existingIds.has(s.sessionId))
+          .map((s) => ({
+            info: { id: s.sessionId, title: !s.title || s.title === "server" ? "Codex" : s.title, createdAt: s.createdAt },
+            messages: [],
+            streaming: "",
+            isWaiting: false,
+            messagesLoaded: false,
+            agentId: "codex" as const,
+          }));
+        return [...prev, ...newStates].sort(
+          (a, b) => new Date(b.info.createdAt).getTime() - new Date(a.info.createdAt).getTime(),
+        );
+      });
+    } catch {}
+  }, []);
+
+  const loadConversations = useCallback(async (sessionId: string) => {
+    if (loadingSessionsRef.current.has(sessionId)) return;
+    loadingSessionsRef.current.add(sessionId);
+    try {
+      const convos = await fetchConversations(sessionId);
+      const codexConvos = convos.filter((c) => c.agentModel === "codex");
+      setSessions((prev) =>
+        prev.map((s) =>
+          s.info.id === sessionId
+            ? { ...s, messages: toMessages(codexConvos), messagesLoaded: true }
+            : s,
+        ),
+      );
+    } catch {
+      setSessions((prev) =>
+        prev.map((s) => (s.info.id === sessionId ? { ...s, messagesLoaded: true } : s)),
+      );
+    }
+  }, []);
+
+  useEffect(() => {
+    const socket = io(`${SERVER_URL}${CODEX_WS_NAMESPACE}`, { transports: ["websocket"] });
+    socketRef.current = socket;
+    setConnectionStatus("connecting");
+
+    socket.on("connect", () => {
+      setConnectionStatus("connected");
+      void loadSessionsFromDB();
+    });
+
+    socket.on("disconnect", () => setConnectionStatus("disconnected"));
+
+    socket.on("session:text", ({ sessionId, text }: { sessionId: string; text: string }) => {
+      streamingRef.current[sessionId] = (streamingRef.current[sessionId] ?? "") + text;
+      const accumulated = streamingRef.current[sessionId];
+      setSessions((prev) =>
+        prev.map((s) =>
+          s.info.id === sessionId ? { ...s, streaming: accumulated, isWaiting: true } : s,
+        ),
+      );
+    });
+
+    socket.on("session:result", ({ sessionId, isError }: { sessionId: string; isError: boolean }) => {
+      const content = (streamingRef.current[sessionId] ?? "").trim();
+      streamingRef.current[sessionId] = "";
+
+      const promptId = pendingPromptIdRef.current[sessionId];
+      const userMsg = pendingUserMsgRef.current[sessionId];
+      if (promptId) {
+        if (userMsg) {
+          saveCodexConversation(sessionId, userMsg.promptId, userMsg.content, "user_message");
+          delete pendingUserMsgRef.current[sessionId];
+        }
+        if (content) {
+          saveCodexConversation(sessionId, promptId, content, "agent_message");
+        }
+        delete pendingPromptIdRef.current[sessionId];
+      }
+
+      const meta: ResultMeta = { result: "", isError, durationMs: 0, costUsd: 0 };
+
+      setSessions((prev) =>
+        prev.map((s) => {
+          if (s.info.id !== sessionId) return s;
+          const newMessages = [...s.messages];
+          if (content) {
+            newMessages.push({
+              id: nextId(),
+              role: "assistant",
+              content,
+              meta,
+              createdAt: new Date(),
+            });
+          }
+          return { ...s, messages: newMessages, streaming: "", isWaiting: false };
+        }),
+      );
+    });
+
+    socket.on("session:exit", ({ sessionId }: { sessionId: string }) => {
+      streamingRef.current[sessionId] = "";
+      setSessions((prev) =>
+        prev.map((s) => (s.info.id === sessionId ? { ...s, streaming: "", isWaiting: false } : s)),
+      );
+    });
+
+    socket.on("session:replaced", ({ oldSessionId, newSessionId }: { oldSessionId: string; newSessionId: string }) => {
+      if (streamingRef.current[oldSessionId] !== undefined) {
+        streamingRef.current[newSessionId] = streamingRef.current[oldSessionId];
+        delete streamingRef.current[oldSessionId];
+      }
+      if (pendingPromptIdRef.current[oldSessionId] !== undefined) {
+        pendingPromptIdRef.current[newSessionId] = pendingPromptIdRef.current[oldSessionId];
+        delete pendingPromptIdRef.current[oldSessionId];
+      }
+      if (pendingUserMsgRef.current[oldSessionId] !== undefined) {
+        pendingUserMsgRef.current[newSessionId] = pendingUserMsgRef.current[oldSessionId];
+        delete pendingUserMsgRef.current[oldSessionId];
+      }
+      setSessions((prev) =>
+        prev.map((s) =>
+          s.info.id === oldSessionId ? { ...s, info: { ...s.info, id: newSessionId } } : s,
+        ),
+      );
+      setSelectedSessionId((prev) => (prev === oldSessionId ? newSessionId : prev));
+    });
+
+    socket.on("error", ({ message }: { message: string }) => setError(message));
+
+    return () => { socket.disconnect(); };
+  }, [loadSessionsFromDB]);
+
+  useEffect(() => {
+    if (!selectedSessionId) return;
+    const session = sessions.find((s) => s.info.id === selectedSessionId);
+    if (!session || session.messagesLoaded) return;
+    void loadConversations(selectedSessionId);
+  }, [selectedSessionId, sessions, loadConversations]);
+
+  const renameSession = useCallback((sessionId: string, newTitle: string) => {
+    setSessions((prev) =>
+      prev.map((s) =>
+        s.info.id === sessionId ? { ...s, info: { ...s.info, title: newTitle } } : s,
+      ),
+    );
+    void updateSessionTitle(sessionId, newTitle).catch(() => undefined);
+  }, []);
+
+  const createSession = useCallback(async (
+    workingDirectory?: string,
+    modelSettings?: AgentModelSettings,
+  ): Promise<string | null> => {
+    setError(null);
+    try {
+      const raw = await apiCreateSession({ workingDirectory, ...modelSettings });
+      const title = raw.workingDirectory
+        ? raw.workingDirectory.replace(/[/\\]+$/, "").split(/[/\\]/).filter(Boolean).at(-1) ?? "Codex"
+        : "Codex";
+
+      const newState: SessionState = {
+        info: { ...raw, title },
+        messages: [],
+        streaming: "",
+        isWaiting: false,
+        messagesLoaded: true,
+        agentId: "codex",
+      };
+
+      setSessions((prev) => [newState, ...prev]);
+      setSelectedSessionId(raw.id);
+      return raw.id;
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Codex 세션 생성 실패");
+      return null;
+    }
+  }, []);
+
+  const sendMessage = useCallback((sessionId: string, text: string, modelSettings?: AgentModelSettings) => {
+    const promptId = crypto.randomUUID();
+    pendingPromptIdRef.current[sessionId] = promptId;
+    pendingUserMsgRef.current[sessionId] = { promptId, content: text };
+
+    setSessions((prev) =>
+      prev.map((s) =>
+        s.info.id === sessionId
+          ? {
+              ...s,
+              messages: [
+                ...s.messages,
+                { id: nextId(), role: "user" as const, content: text, createdAt: new Date() },
+              ],
+              isWaiting: true,
+            }
+          : s,
+      ),
+    );
+
+    socketRef.current?.emit("session:message", {
+      sessionId,
+      input: text,
+      ...modelSettings,
+    });
+  }, []);
+
+  const terminateSession = useCallback(async (sessionId: string) => {
+    try {
+      await deleteCodexSession(sessionId);
+      setSessions((prev) => prev.filter((s) => s.info.id !== sessionId));
+      setSelectedSessionId((prev) => (prev === sessionId ? null : prev));
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "세션 삭제 실패");
+    }
+  }, []);
+
+  const selectedSession = sessions.find((s) => s.info.id === selectedSessionId) ?? null;
+
+  return {
+    connectionStatus,
+    sessions,
+    selectedSession,
+    selectedSessionId,
+    error,
+    createSession,
+    selectSession: setSelectedSessionId,
+    sendMessage,
+    terminateSession,
+    renameSession,
+  };
+}

package/apps/web/src/features/chat/hooks/useGeminiSessions.ts

@@ -0,0 +1,255 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import { io, type Socket } from "socket.io-client";
+
+import { GEMINI_WS_NAMESPACE, SERVER_URL } from "@/lib/constants";
+import {
+  createGeminiSession as apiCreateSession,
+  deleteGeminiSession,
+  fetchConversations,
+  fetchDBSessions,
+  saveGeminiConversation,
+  updateSessionTitle,
+} from "../api/sessions.api";
+import type { DBConversation, SessionInfo } from "../api/sessions.api";
+import type { ChatMessage, ResultMeta, SessionState, ToolUseBlock } from "./useClaudeSessions";
+
+export type { SessionInfo };
+
+// ─── 헬퍼 ────────────────────────────────────────────────────────────────────
+
+let msgId = 0;
+const nextId = () => String(++msgId);
+
+function toMessages(convos: DBConversation[]): ChatMessage[] {
+  return convos.map((c) => ({
+    id: c.id,
+    role: (c.type === "user_message" ? "user" : "assistant") as ChatMessage["role"],
+    content: c.content,
+    createdAt: new Date(c.createdAt),
+  }));
+}
+
+// ─── Hook ────────────────────────────────────────────────────────────────────
+
+export function useGeminiSessions() {
+  const socketRef = useRef<Socket | null>(null);
+  const [connectionStatus, setConnectionStatus] = useState<"disconnected" | "connecting" | "connected">("disconnected");
+  const [sessions, setSessions] = useState<SessionState[]>([]);
+  const [selectedSessionId, setSelectedSessionId] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  const streamingRef = useRef<Record<string, string>>({});
+  const pendingPromptIdRef = useRef<Record<string, string>>({});
+  const loadingSessionsRef = useRef<Set<string>>(new Set());
+
+  // ─── DB 세션 로드 ──────────────────────────────────────────────────────────
+
+  const loadSessionsFromDB = useCallback(async () => {
+    try {
+      const dbSessions = await fetchDBSessions('gemini');
+      setSessions((prev) => {
+        const existingIds = new Set(prev.map((s) => s.info.id));
+        // Gemini 세션만 필터링 (agentModel='gemini' 인 conversation이 있는 sessionId)
+        // 단순화: DB sessions 전체를 불러오되 이미 있는 건 스킵
+        const newStates: SessionState[] = dbSessions
+          .filter((s) => !existingIds.has(s.sessionId))
+          .map((s) => ({
+            info: { id: s.sessionId, title: !s.title || s.title === "server" ? "Gemini" : s.title, createdAt: s.createdAt },
+            messages: [],
+            streaming: "",
+            isWaiting: false,
+            messagesLoaded: false,
+            agentId: "gemini" as const,
+          }));
+        return [...prev, ...newStates].sort(
+          (a, b) => new Date(b.info.createdAt).getTime() - new Date(a.info.createdAt).getTime(),
+        );
+      });
+    } catch {}
+  }, []);
+
+  // ─── 대화 기록 로드 ────────────────────────────────────────────────────────
+
+  const loadConversations = useCallback(async (sessionId: string) => {
+    if (loadingSessionsRef.current.has(sessionId)) return;
+    loadingSessionsRef.current.add(sessionId);
+    try {
+      const convos = await fetchConversations(sessionId);
+      // gemini 대화만 필터
+      const geminiConvos = convos.filter((c) => c.agentModel === "gemini");
+      setSessions((prev) =>
+        prev.map((s) =>
+          s.info.id === sessionId
+            ? { ...s, messages: toMessages(geminiConvos), messagesLoaded: true }
+            : s,
+        ),
+      );
+    } catch {
+      setSessions((prev) =>
+        prev.map((s) => (s.info.id === sessionId ? { ...s, messagesLoaded: true } : s)),
+      );
+    }
+  }, []);
+
+  // ─── WebSocket ─────────────────────────────────────────────────────────────
+
+  useEffect(() => {
+    const socket = io(`${SERVER_URL}${GEMINI_WS_NAMESPACE}`, { transports: ["websocket"] });
+    socketRef.current = socket;
+    setConnectionStatus("connecting");
+
+    socket.on("connect", () => {
+      setConnectionStatus("connected");
+      void loadSessionsFromDB();
+    });
+
+    socket.on("disconnect", () => setConnectionStatus("disconnected"));
+
+    socket.on("session:text", ({ sessionId, text }: { sessionId: string; text: string }) => {
+      streamingRef.current[sessionId] = (streamingRef.current[sessionId] ?? "") + text;
+      const accumulated = streamingRef.current[sessionId];
+      setSessions((prev) =>
+        prev.map((s) =>
+          s.info.id === sessionId ? { ...s, streaming: accumulated, isWaiting: true } : s,
+        ),
+      );
+    });
+
+    socket.on("session:result", ({ sessionId, isError }: { sessionId: string; isError: boolean }) => {
+      const content = (streamingRef.current[sessionId] ?? "").trim();
+      streamingRef.current[sessionId] = "";
+
+      const promptId = pendingPromptIdRef.current[sessionId];
+      if (promptId && content) {
+        saveGeminiConversation(sessionId, promptId, content, "agent_message");
+        delete pendingPromptIdRef.current[sessionId];
+      }
+
+      const meta: ResultMeta = { result: "", isError, durationMs: 0, costUsd: 0 };
+
+      setSessions((prev) =>
+        prev.map((s) => {
+          if (s.info.id !== sessionId) return s;
+          const newMessages = [...s.messages];
+          if (content) {
+            newMessages.push({
+              id: nextId(),
+              role: "assistant",
+              content,
+              meta,
+              createdAt: new Date(),
+            });
+          }
+          return { ...s, messages: newMessages, streaming: "", isWaiting: false };
+        }),
+      );
+    });
+
+    socket.on("session:exit", ({ sessionId }: { sessionId: string }) => {
+      streamingRef.current[sessionId] = "";
+      setSessions((prev) =>
+        prev.map((s) => (s.info.id === sessionId ? { ...s, streaming: "", isWaiting: false } : s)),
+      );
+    });
+
+    socket.on("error", ({ message }: { message: string }) => setError(message));
+
+    return () => { socket.disconnect(); };
+  }, [loadSessionsFromDB]);
+
+  // ─── 세션 선택 시 대화 기록 로드 ─────────────────────────────────────────
+
+  useEffect(() => {
+    if (!selectedSessionId) return;
+    const session = sessions.find((s) => s.info.id === selectedSessionId);
+    if (!session || session.messagesLoaded) return;
+    void loadConversations(selectedSessionId);
+  }, [selectedSessionId, sessions, loadConversations]);
+
+  // ─── 공개 API ─────────────────────────────────────────────────────────────
+
+  const renameSession = useCallback((sessionId: string, newTitle: string) => {
+    setSessions((prev) =>
+      prev.map((s) =>
+        s.info.id === sessionId ? { ...s, info: { ...s.info, title: newTitle } } : s,
+      ),
+    );
+    void updateSessionTitle(sessionId, newTitle).catch(() => undefined);
+  }, []);
+
+  const createSession = useCallback(async (workingDirectory?: string): Promise<string | null> => {
+    setError(null);
+    try {
+      const raw = await apiCreateSession(workingDirectory);
+      const title = raw.workingDirectory
+        ? raw.workingDirectory.replace(/[/\\]+$/, "").split(/[/\\]/).filter(Boolean).at(-1) ?? "Gemini"
+        : "Gemini";
+
+      const newState: SessionState = {
+        info: { ...raw, title },
+        messages: [],
+        streaming: "",
+        isWaiting: false,
+        messagesLoaded: true,
+        agentId: "gemini",
+      };
+
+      setSessions((prev) => [newState, ...prev]);
+      setSelectedSessionId(raw.id);
+      return raw.id;
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Gemini 세션 생성 실패");
+      return null;
+    }
+  }, []);
+
+  const sendMessage = useCallback((sessionId: string, text: string) => {
+    const promptId = crypto.randomUUID();
+    pendingPromptIdRef.current[sessionId] = promptId;
+
+    setSessions((prev) =>
+      prev.map((s) =>
+        s.info.id === sessionId
+          ? {
+              ...s,
+              messages: [
+                ...s.messages,
+                { id: nextId(), role: "user" as const, content: text, createdAt: new Date() },
+              ],
+              isWaiting: true,
+            }
+          : s,
+      ),
+    );
+
+    saveGeminiConversation(sessionId, promptId, text, "user_message");
+    socketRef.current?.emit("session:message", { sessionId, input: text });
+  }, []);
+
+  const terminateSession = useCallback(async (sessionId: string) => {
+    try {
+      await deleteGeminiSession(sessionId);
+      setSessions((prev) => prev.filter((s) => s.info.id !== sessionId));
+      setSelectedSessionId((prev) => (prev === sessionId ? null : prev));
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "세션 삭제 실패");
+    }
+  }, []);
+
+  const selectedSession = sessions.find((s) => s.info.id === selectedSessionId) ?? null;
+
+  return {
+    connectionStatus,
+    sessions,
+    selectedSession,
+    selectedSessionId,
+    error,
+    createSession,
+    selectSession: setSelectedSessionId,
+    sendMessage,
+    terminateSession,
+    renameSession,
+  };
+}

package/apps/web/src/features/chat/hooks/useSessionCommand.ts

@@ -0,0 +1,66 @@
+"use client";
+
+import { useCallback } from "react";
+
+import { getClaudeStatus } from "@/features/auth/api/auth.api";
+import type { AgentModelSettingsByAgent } from "../lib/agentModelOptions";
+import type { ChatMessage, SessionState } from "./useClaudeSessions";
+
+interface UseSessionCommandParams {
+  selectedSession: SessionState | null;
+  selectedSessionId: string | null;
+  sendMessage: (sessionId: string, text: string, modelSettingsByAgent?: AgentModelSettingsByAgent) => void;
+  modelSettingsByAgent?: AgentModelSettingsByAgent;
+  injectClaudeMessage: (sessionId: string, message: Omit<ChatMessage, "id" | "createdAt">) => void;
+}
+
+export function useSessionCommand({
+  selectedSession,
+  selectedSessionId,
+  sendMessage,
+  modelSettingsByAgent,
+  injectClaudeMessage,
+}: UseSessionCommandParams) {
+  return useCallback(
+    async (text: string) => {
+      const trimmed = text.trim();
+      if (!selectedSessionId || !trimmed) return;
+
+      if (trimmed === "/status" && selectedSession?.agentId === "claude") {
+        injectClaudeMessage(selectedSessionId, { role: "user", content: "/status" });
+        try {
+          const data = await getClaudeStatus();
+          const auth = data.auth;
+          const authLines: string[] = [];
+
+          if (auth.loggedIn) {
+            authLines.push(`인증         ✅ 로그인됨 (${auth.authMethod})`);
+            if (auth.email) authLines.push(`계정         ${auth.email}`);
+            if (auth.orgName) authLines.push(`조직         ${auth.orgName}`);
+            if (auth.subscriptionType) authLines.push(`구독         ${auth.subscriptionType}`);
+          } else {
+            authLines.push("인증         ❌ 로그아웃 상태");
+          }
+
+          const lines = [
+            `Claude Code  ${data.version}`,
+            `플랫폼       ${data.platform}`,
+            ...authLines,
+            `활성 세션    ${data.activeSessions}개`,
+          ].join("\n");
+
+          injectClaudeMessage(selectedSessionId, { role: "system", content: lines });
+        } catch {
+          injectClaudeMessage(selectedSessionId, {
+            role: "system",
+            content: "❌ 상태 조회 실패 — 서버 연결을 확인하세요.",
+          });
+        }
+        return;
+      }
+
+      sendMessage(selectedSessionId, trimmed, modelSettingsByAgent);
+    },
+    [injectClaudeMessage, modelSettingsByAgent, selectedSession, selectedSessionId, sendMessage],
+  );
+}

package/apps/web/src/features/chat/hooks/useSessionRename.ts

@@ -0,0 +1,61 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+
+export function useSessionRename(onRename: (sessionId: string, newTitle: string) => void) {
+  const [menuOpenId, setMenuOpenId] = useState<string | null>(null);
+  const [renamingId, setRenamingId] = useState<string | null>(null);
+  const [renameValue, setRenameValue] = useState("");
+  const menuRef = useRef<HTMLDivElement>(null);
+  const skipNextBlurRef = useRef(false);
+
+  useEffect(() => {
+    if (!menuOpenId) return;
+
+    const handler = (event: MouseEvent) => {
+      if (menuRef.current && !menuRef.current.contains(event.target as Node)) {
+        setMenuOpenId(null);
+      }
+    };
+
+    document.addEventListener("mousedown", handler);
+    return () => document.removeEventListener("mousedown", handler);
+  }, [menuOpenId]);
+
+  const startRename = useCallback((sessionId: string, currentTitle: string) => {
+    setMenuOpenId(null);
+    setRenamingId(sessionId);
+    setRenameValue(currentTitle);
+  }, []);
+
+  const confirmRename = useCallback(() => {
+    if (skipNextBlurRef.current) {
+      skipNextBlurRef.current = false;
+      return;
+    }
+
+    if (renamingId && renameValue.trim()) {
+      onRename(renamingId, renameValue.trim());
+    }
+    setRenamingId(null);
+    setRenameValue("");
+  }, [onRename, renameValue, renamingId]);
+
+  const cancelRename = useCallback(() => {
+    skipNextBlurRef.current = true;
+    setRenamingId(null);
+    setRenameValue("");
+  }, []);
+
+  return {
+    menuOpenId,
+    setMenuOpenId,
+    renamingId,
+    renameValue,
+    setRenameValue,
+    menuRef,
+    startRename,
+    confirmRename,
+    cancelRename,
+  };
+}

package/apps/web/src/features/chat/hooks/useSessionWorkingDirectories.ts

@@ -0,0 +1,34 @@
+"use client";
+
+import { useCallback, useEffect, useState } from "react";
+
+export function useSessionWorkingDirectories(selectedSessionId: string | null) {
+  const [sessionDirs, setSessionDirs] = useState<Record<string, string>>({});
+  const [currentDir, setCurrentDir] = useState("");
+
+  useEffect(() => {
+    setCurrentDir(selectedSessionId ? (sessionDirs[selectedSessionId] ?? "") : "");
+  }, [selectedSessionId, sessionDirs]);
+
+  const handleDirChange = useCallback(
+    (path: string) => {
+      setCurrentDir(path);
+      if (selectedSessionId) {
+        setSessionDirs((prev) => ({ ...prev, [selectedSessionId]: path }));
+      }
+    },
+    [selectedSessionId],
+  );
+
+  const assignDirectoryToSession = useCallback((sessionId: string, path: string) => {
+    setSessionDirs((prev) => ({ ...prev, [sessionId]: path }));
+    setCurrentDir(path);
+  }, []);
+
+  return {
+    sessionDirs,
+    currentDir,
+    handleDirChange,
+    assignDirectoryToSession,
+  };
+}