import {  type Dispatch,  type ReactNode,  createContext,  createElement,  useContext,  useEffect,  useReducer,} from "react"; import {  type ProviderEvent,  type ProviderSession,  type StateBootstrapResult,  type StateBootstrapThread,  type StateEvent,  type TerminalEvent,  normalizeProjectScripts,} from "@t3tools/contracts";import { DEFAULT_MODEL, resolveModelSlug } from "./model-logic";import {  applyEventToMessages,  asObject,  asString,  deriveTurnDiffSummaries,  inferCheckpointTurnCountByTurnId,  evolveSession,} from "./session-logic";import {  type ChatAttachment,  DEFAULT_THREAD_TERMINAL_ID,  DEFAULT_RUNTIME_MODE,  MAX_THREAD_TERMINAL_COUNT,  type ProjectScript,  type Project,  type RuntimeMode,  type Thread,  type ThreadTerminalGroup,} from "./types"; // ── Actions ────────────────────────────────────────────────────────── type Action =  | { type: "HYDRATE_FROM_SERVER"; snapshot: StateBootstrapResult }  | { type: "APPLY_STATE_EVENT"; event: StateEvent }  | { type: "ADD_PROJECT"; project: Project }  | { type: "SET_PROJECT_SCRIPTS"; projectId: string; scripts: ProjectScript[] }  | { type: "SYNC_PROJECTS"; projects: Project[] }  | { type: "SET_THREADS_HYDRATED"; hydrated: boolean }  | { type: "TOGGLE_PROJECT"; projectId: string }  | { type: "DELETE_PROJECT"; projectId: string }  | { type: "ADD_THREAD"; thread: Thread }  | { type: "TOGGLE_THREAD_TERMINAL"; threadId: string }  | { type: "SET_THREAD_TERMINAL_OPEN"; threadId: string; open: boolean }  | { type: "SET_THREAD_TERMINAL_HEIGHT"; threadId: string; height: number }  | { type: "SPLIT_THREAD_TERMINAL"; threadId: string; terminalId: string }  | { type: "NEW_THREAD_TERMINAL"; threadId: string; terminalId: string }  | { type: "SET_THREAD_ACTIVE_TERMINAL"; threadId: string; terminalId: string }  | { type: "CLOSE_THREAD_TERMINAL"; threadId: string; terminalId: string }  | {      type: "APPLY_EVENT";      event: ProviderEvent;      activeAssistantItemRef: { current: string | null };      activeThreadId?: string | null;    }  | { type: "APPLY_TERMINAL_EVENT"; event: TerminalEvent }  | { type: "UPDATE_SESSION"; threadId: string; session: ProviderSession }  | {      type: "PUSH_USER_MESSAGE";      threadId: string;      id: string;      text: string;      attachments?: ChatAttachment[];    }  | { type: "SET_ERROR"; threadId: string; error: string | null }  | { type: "SET_THREAD_TITLE"; threadId: string; title: string }  | { type: "SET_THREAD_MODEL"; threadId: string; model: string }  | {      type: "REVERT_TO_CHECKPOINT";      threadId: string;      sessionId: string;      threadRuntimeId: string;      turnCount: number;      messageCount: number;    }  | {      type: "SET_THREAD_TURN_CHECKPOINT_COUNTS";      threadId: string;      checkpointTurnCountByTurnId: Record<string, number>;    }  | {      type: "SET_THREAD_BRANCH";      threadId: string;      branch: string | null;      worktreePath: string | null;    }  | { type: "MARK_THREAD_VISITED"; threadId: string; visitedAt?: string }  | { type: "SET_RUNTIME_MODE"; mode: RuntimeMode }  | { type: "DELETE_THREAD"; threadId: string }; // ── State ──────────────────────────────────────────────────────────── export interface AppState {  projects: Project[];  threads: Thread[];  threadsHydrated: boolean;  runtimeMode: RuntimeMode;} const RUNTIME_MODE_STORAGE_KEY = "t3code:runtime-mode"; const initialState: AppState = {  projects: [],  threads: [],  threadsHydrated: false,  runtimeMode: DEFAULT_RUNTIME_MODE,}; // ── Helpers ────────────────────────────────────────────────────────── function readPersistedState(): AppState {  if (typeof window === "undefined") return initialState;   try {    const rawRuntimeMode = window.localStorage.getItem(RUNTIME_MODE_STORAGE_KEY);    const runtimeMode =      rawRuntimeMode === "approval-required" || rawRuntimeMode === "full-access"        ? rawRuntimeMode        : DEFAULT_RUNTIME_MODE;    return {      ...initialState,      runtimeMode,    };  } catch {    return initialState;  }} function persistState(state: AppState): void {  if (typeof window === "undefined") return;   try {    window.localStorage.setItem(RUNTIME_MODE_STORAGE_KEY, state.runtimeMode);  } catch {    // Ignore storage failures to avoid breaking chat UX.  }} function updateThread(  threads: Thread[],  threadId: string,  updater: (t: Thread) => Thread,): Thread[] {  return threads.map((t) => (t.id === threadId ? updater(t) : t));} function mergeTurnDiffSummaries(  existing: Thread["turnDiffSummaries"],  next: Thread["turnDiffSummaries"],): Thread["turnDiffSummaries"] {  if (next.length === 0) return existing;   const existingByTurnId = new Map(existing.map((summary) => [summary.turnId, summary] as const));  const merged = next.map((summary) => {    const previous = existingByTurnId.get(summary.turnId);    if (!previous) {      return summary;    }     const files =      summary.files.length === 0 && previous.files.length > 0 ? previous.files : summary.files;     return {      ...summary,      files,      ...(summary.assistantMessageId        ? {}        : previous.assistantMessageId          ? { assistantMessageId: previous.assistantMessageId }          : {}),      ...(typeof summary.checkpointTurnCount === "number"        ? {}        : typeof previous.checkpointTurnCount === "number"          ? { checkpointTurnCount: previous.checkpointTurnCount }          : {}),    };  });   const mergedTurnIds = new Set(merged.map((summary) => summary.turnId));  for (const summary of existing) {    if (!mergedTurnIds.has(summary.turnId)) {      merged.push(summary);    }  }   const sorted = merged.toSorted((a, b) => {    const aTime = Date.parse(a.completedAt);    const bTime = Date.parse(b.completedAt);    if (Number.isNaN(aTime) || Number.isNaN(bTime)) {      return b.completedAt.localeCompare(a.completedAt);    }    return bTime - aTime;  });   const inferredTurnCountByTurnId = inferCheckpointTurnCountByTurnId(sorted);  return sorted.map((summary) =>    typeof summary.checkpointTurnCount === "number"      ? summary      : Object.assign({}, summary, {          checkpointTurnCount: inferredTurnCountByTurnId[summary.turnId],        }),  );} function hydrateThreadFromBootstrap(  thread: StateBootstrapThread,  existing: Thread | undefined,): Thread {  return normalizeThreadTerminals({    id: thread.id,    codexThreadId: thread.codexThreadId ?? null,    projectId: thread.projectId,    title: thread.title,    model: resolveModelSlug(thread.model),    terminalOpen: thread.terminalOpen,    terminalHeight: thread.terminalHeight,    terminalIds: thread.terminalIds,    runningTerminalIds: thread.runningTerminalIds,    activeTerminalId: thread.activeTerminalId,    terminalGroups: thread.terminalGroups,    activeTerminalGroupId: thread.activeTerminalGroupId,    session: existing?.session ?? null,    messages: thread.messages.map((message) => ({      id: message.id,      role: message.role,      text: message.text,      ...(message.attachments        ? { attachments: message.attachments.map((attachment) => ({ ...attachment })) }        : {}),      createdAt: message.createdAt,      streaming: message.streaming,    })),    events: existing?.events ?? [],    error: existing?.error ?? null,    createdAt: thread.createdAt,    latestTurnId: thread.latestTurnId,    latestTurnStartedAt: thread.latestTurnStartedAt,    latestTurnCompletedAt: thread.latestTurnCompletedAt,    latestTurnDurationMs: thread.latestTurnDurationMs,    lastVisitedAt: thread.lastVisitedAt ?? thread.createdAt,    branch: thread.branch ?? null,    worktreePath: thread.worktreePath ?? null,    turnDiffSummaries: thread.turnDiffSummaries ?? [],  });} function upsertThreadMessage(messages: Thread["messages"], message: Thread["messages"][number]) {  const index = messages.findIndex((entry) => entry.id === message.id);  if (index < 0) {    return [...messages, message];  }  const next = [...messages];  next[index] = message;  return next;} function normalizeTerminalIds(terminalIds: string[]): string[] {  const ids = terminalIds.map((id) => id.trim()).filter((id) => id.length > 0);  const unique = [...new Set(ids)].slice(0, MAX_THREAD_TERMINAL_COUNT);  if (unique.length > 0) {    return unique;  }  return [DEFAULT_THREAD_TERMINAL_ID];} function normalizeRunningTerminalIds(  runningTerminalIds: string[],  terminalIds: string[],): string[] {  if (runningTerminalIds.length === 0) return [];  const validTerminalIdSet = new Set(terminalIds);  return [...new Set(runningTerminalIds)]    .map((id) => id.trim())    .filter((id) => id.length > 0 && validTerminalIdSet.has(id));}  function normalizeTerminalGroupIds(terminalIds: string[]): string[] {  return [...new Set(terminalIds.map((id) => id.trim()).filter((id) => id.length > 0))];} function fallbackGroupId(terminalId: string): string {  return `group-${terminalId}`;} function assignUniqueGroupId(groupId: string, usedGroupIds: Set<string>): string {  if (!usedGroupIds.has(groupId)) {    usedGroupIds.add(groupId);    return groupId;  }  let suffix = 2;  while (usedGroupIds.has(`${groupId}-${suffix}`)) {    suffix += 1;  }  const uniqueGroupId = `${groupId}-${suffix}`;  usedGroupIds.add(uniqueGroupId);  return uniqueGroupId;} function normalizeTerminalGroups(thread: Thread, terminalIds: string[]): ThreadTerminalGroup[] {  const validTerminalIdSet = new Set(terminalIds);  const assignedTerminalIds = new Set<string>();  const usedGroupIds = new Set<string>();  const groups: ThreadTerminalGroup[] = [];   for (const group of thread.terminalGroups) {    const groupTerminalIds = normalizeTerminalGroupIds(group.terminalIds).filter((terminalId) => {      if (!validTerminalIdSet.has(terminalId)) return false;      if (assignedTerminalIds.has(terminalId)) return false;      return true;    });    if (groupTerminalIds.length === 0) continue;    for (const terminalId of groupTerminalIds) {      assignedTerminalIds.add(terminalId);    }    const baseGroupId =      group.id.trim().length > 0        ? group.id.trim()        : fallbackGroupId(groupTerminalIds[0] ?? DEFAULT_THREAD_TERMINAL_ID);    groups.push({      id: assignUniqueGroupId(baseGroupId, usedGroupIds),      terminalIds: groupTerminalIds,    });  }   for (const terminalId of terminalIds) {    if (assignedTerminalIds.has(terminalId)) continue;    groups.push({      id: assignUniqueGroupId(fallbackGroupId(terminalId), usedGroupIds),      terminalIds: [terminalId],    });  }   if (groups.length > 0) {    return groups;  }   return [    {      id: fallbackGroupId(DEFAULT_THREAD_TERMINAL_ID),      terminalIds: [DEFAULT_THREAD_TERMINAL_ID],    },  ];} function findGroupIndexByTerminalId(  terminalGroups: ThreadTerminalGroup[],  terminalId: string,): number {  return terminalGroups.findIndex((group) => group.terminalIds.includes(terminalId));} function normalizeThreadTerminals(thread: Thread): Thread {  const terminalIds = normalizeTerminalIds(thread.terminalIds);  const activeTerminalId = terminalIds.includes(thread.activeTerminalId)    ? thread.activeTerminalId    : (terminalIds[0] ?? DEFAULT_THREAD_TERMINAL_ID);  const terminalGroups = normalizeTerminalGroups(thread, terminalIds);  const activeGroupIndexFromId = terminalGroups.findIndex(    (group) => group.id === thread.activeTerminalGroupId,  );  const activeGroupIndexFromTerminal = findGroupIndexByTerminalId(terminalGroups, activeTerminalId);  const activeGroupIndex =    activeGroupIndexFromId >= 0      ? activeGroupIndexFromId      : activeGroupIndexFromTerminal >= 0        ? activeGroupIndexFromTerminal        : 0;  const activeTerminalGroupId =    terminalGroups[activeGroupIndex]?.id ??    terminalGroups[0]?.id ??    fallbackGroupId(activeTerminalId);   return {    ...thread,    terminalIds,    runningTerminalIds: normalizeRunningTerminalIds(thread.runningTerminalIds, terminalIds),    activeTerminalId,    terminalGroups,    activeTerminalGroupId,  };} function closeThreadTerminal(thread: Thread, terminalId: string): Thread {  if (!thread.terminalIds.includes(terminalId)) {    return thread;  }   const remainingTerminalIds = thread.terminalIds.filter((id) => id !== terminalId);  if (remainingTerminalIds.length === 0) {    const nextTerminalGroupId = fallbackGroupId(DEFAULT_THREAD_TERMINAL_ID);    return normalizeThreadTerminals({      ...thread,      terminalOpen: false,      terminalIds: [DEFAULT_THREAD_TERMINAL_ID],      runningTerminalIds: [],      activeTerminalId: DEFAULT_THREAD_TERMINAL_ID,      terminalGroups: [        {          id: nextTerminalGroupId,          terminalIds: [DEFAULT_THREAD_TERMINAL_ID],        },      ],      activeTerminalGroupId: nextTerminalGroupId,    });  }   const closedTerminalIndex = thread.terminalIds.indexOf(terminalId);  const closedTerminalGroup = thread.terminalGroups.find((group) =>    group.terminalIds.includes(terminalId),  );  const closedTerminalGroupIndex = closedTerminalGroup    ? closedTerminalGroup.terminalIds.indexOf(terminalId)    : -1;  const remainingTerminalsInClosedGroup = (closedTerminalGroup?.terminalIds ?? []).filter(    (id) => id !== terminalId,  );  const nextActiveTerminalId =    thread.activeTerminalId === terminalId      ? (remainingTerminalsInClosedGroup[          Math.min(closedTerminalGroupIndex, remainingTerminalsInClosedGroup.length - 1)        ] ??        remainingTerminalIds[Math.min(closedTerminalIndex, remainingTerminalIds.length - 1)] ??        remainingTerminalIds[0] ??        DEFAULT_THREAD_TERMINAL_ID)      : thread.activeTerminalId;  const nextTerminalGroups = thread.terminalGroups    .map((group) => ({      ...group,      terminalIds: group.terminalIds.filter((id) => id !== terminalId),    }))    .filter((group) => group.terminalIds.length > 0);   return normalizeThreadTerminals({    ...thread,    terminalIds: remainingTerminalIds,    runningTerminalIds: thread.runningTerminalIds.filter((id) => id !== terminalId),    activeTerminalId: nextActiveTerminalId,    terminalGroups: nextTerminalGroups,  });} function findThreadBySessionId(threads: Thread[], sessionId: string): Thread | undefined {  return threads.find((t) => t.session?.sessionId === sessionId);} function getEventTurnId(event: ProviderEvent): string | undefined {  if (event.turnId) return event.turnId;  const payload = asObject(event.payload);  const turn = asObject(payload?.turn);  return asString(turn?.id);} function getEventThreadId(event: ProviderEvent): string | undefined {  if (event.threadId) return event.threadId;  const payload = asObject(event.payload);  const payloadThread = asObject(payload?.thread);  const payloadMessage = asObject(payload?.msg);  return (    asString(payload?.threadId) ??    asString(payloadThread?.id) ??    asString(payload?.conversationId) ??    asString(payload?.thread_id) ??    asString(payloadMessage?.thread_id)  );} function shouldIgnoreForeignThreadEvent(thread: Thread, event: ProviderEvent): boolean {  const eventThreadId = getEventThreadId(event);  if (!eventThreadId) {    return false;  }   const expectedThreadId = thread.session?.threadId ?? thread.codexThreadId;  if (!expectedThreadId || eventThreadId === expectedThreadId) {    return false;  }   // During connect, accept a thread/started notification as an identity rebind.  if (event.method === "thread/started" && thread.session?.status === "connecting") {    return false;  }   return true;} function durationMs(startIso: string, endIso: string): number | undefined {  const start = Date.parse(startIso);  const end = Date.parse(endIso);  if (Number.isNaN(start) || Number.isNaN(end) || end < start) {

Lines 1–500 of 1289. Load more