import {  type EnvironmentId,  isProviderDriverKind,  ProjectId,  type MessageId,  type ModelSelection,  type ProviderDriverKind,  type ServerProvider,  type ScopedProjectRef,  type ScopedThreadRef,  type ThreadId,  type TurnId,} from "@t3tools/contracts";import { type ChatMessage, type SessionPhase, type Thread, type ThreadShell } from "../types";import { type ComposerImageAttachment, type DraftThreadState } from "../composerDraftStore";import * as Schema from "effect/Schema";import { appAtomRegistry } from "../rpc/atomRegistry";import { environmentThreadDetails } from "../state/threads";import {  filterTerminalContextsWithText,  stripInlineTerminalContextPlaceholders,  type TerminalContextDraft,} from "../lib/terminalContext";import type { DraftThreadEnvMode } from "../composerDraftStore";import type { ComposerSubmissionIntent } from "../composer-logic";import type { TimelineEntry } from "../session-logic"; export const LAST_INVOKED_SCRIPT_BY_PROJECT_KEY = "t3code:last-invoked-script-by-project";export const MAX_HIDDEN_MOUNTED_TERMINAL_THREADS = 10;export const MAX_HIDDEN_MOUNTED_PREVIEW_THREADS = 3;export const ENVIRONMENT_RECONNECT_WARNING_GRACE_MS = 2_000; export const LastInvokedScriptByProjectSchema = Schema.Record(ProjectId, Schema.String); export function shouldDockDraftHeroForSubmission(input: {  isDraftHeroState: boolean;  activeThreadKey: string | null;  submissionIntent: ComposerSubmissionIntent;}): boolean {  return (    input.submissionIntent === "foreground" &&    input.isDraftHeroState &&    input.activeThreadKey !== null  );} export function shouldReleaseTimelineAnchorForToolActivity(input: {  anchorMessageId: MessageId | null;  liveFollowEnabled: boolean;  runningTurnId: TurnId | null;  timelineEntries: ReadonlyArray<TimelineEntry>;}): boolean {  if (input.anchorMessageId === null || !input.liveFollowEnabled || input.runningTurnId === null) {    return false;  }   return input.timelineEntries.some((timelineEntry) => {    if (timelineEntry.kind !== "work" || timelineEntry.entry.turnId !== input.runningTurnId) {      return false;    }     const entry = timelineEntry.entry;    return (      entry.tone === "tool" ||      entry.itemType !== undefined ||      entry.requestKind !== undefined ||      (entry.command?.trim().length ?? 0) > 0    );  });} export function resolveDraftHeroState(input: {  isLocalDraftThread: boolean;  hasTimelineEntries: boolean;  isWorking: boolean;  draftHeroDockRequested: boolean;  backgroundSubmissionPending: boolean;}): boolean {  if (input.backgroundSubmissionPending) {    return true;  }  return (    input.isLocalDraftThread &&    !input.hasTimelineEntries &&    !input.isWorking &&    !input.draftHeroDockRequested  );} export function resolveDraftPromotionNavigationTarget(input: {  serverThreadRef: ScopedThreadRef | null;  serverThreadStarted: boolean;  backgroundSubmissionPending: boolean;}): ScopedThreadRef | null {  if (input.backgroundSubmissionPending) {    return null;  }  return input.serverThreadStarted ? input.serverThreadRef : null;} export function scheduleEnvironmentReconnectWarning(showWarning: () => void): () => void {  const timeoutId = globalThis.setTimeout(showWarning, ENVIRONMENT_RECONNECT_WARNING_GRACE_MS);  return () => globalThis.clearTimeout(timeoutId);} export function hasEnvironmentReconnectWarningGraceElapsed(  activeEnvironmentId: EnvironmentId | null,  elapsedEnvironmentId: EnvironmentId | null,): boolean {  return activeEnvironmentId !== null && activeEnvironmentId === elapsedEnvironmentId;} export function startNewThreadForProject(  projectRef: ScopedProjectRef | null,  handleNewThread: (projectRef: ScopedProjectRef) => Promise<unknown>,): boolean {  if (projectRef === null) return false;  void handleNewThread(projectRef);   return true;} export function resolveThreadMetadataUpdateForNextTurn(input: {  currentModelSelection: ModelSelection;  nextModelSelection?: ModelSelection;  currentBranch: string | null;  nextBranch?: string;}): {  modelSelection?: ModelSelection;  branch?: string;  worktreePath?: null;} | null {  const nextModelSelection = input.nextModelSelection;  const modelSelectionChanged =    nextModelSelection !== undefined &&    (nextModelSelection.model !== input.currentModelSelection.model ||      nextModelSelection.instanceId !== input.currentModelSelection.instanceId ||      JSON.stringify(nextModelSelection.options ?? null) !==        JSON.stringify(input.currentModelSelection.options ?? null));  const branchChanged = input.nextBranch !== undefined && input.nextBranch !== input.currentBranch;  if (!modelSelectionChanged && !branchChanged) {    return null;  }  return {    ...(modelSelectionChanged ? { modelSelection: nextModelSelection } : {}),    ...(branchChanged ? { branch: input.nextBranch, worktreePath: null } : {}),  };} export function buildLocalDraftThread(  threadId: ThreadId,  draftThread: DraftThreadState,  fallbackModelSelection: ModelSelection,): Thread {  return {    id: threadId,    environmentId: draftThread.environmentId,    projectId: draftThread.projectId,    title: "New thread",    modelSelection: fallbackModelSelection,    runtimeMode: draftThread.runtimeMode,    interactionMode: draftThread.interactionMode,    session: null,    messages: [],    createdAt: draftThread.createdAt,    updatedAt: draftThread.createdAt,    archivedAt: null,    settledOverride: null,    settledAt: null,    deletedAt: null,    latestTurn: null,    branch: draftThread.branch,    worktreePath: draftThread.worktreePath,    checkpoints: [],    activities: [],    proposedPlans: [],  };} export function buildLoadingThreadFromShell(shell: ThreadShell): Thread {  return {    ...shell,    messages: [],    proposedPlans: [],    activities: [],    checkpoints: [],    deletedAt: null,  };} export function shouldWriteThreadErrorToCurrentServerThread(input: {  activeServerThread:    | {        environmentId: EnvironmentId;        id: ThreadId;      }    | null    | undefined;  routeThreadRef: ScopedThreadRef;  targetThreadId: ThreadId;}): boolean {  return Boolean(    input.activeServerThread &&    input.targetThreadId === input.routeThreadRef.threadId &&    input.activeServerThread.environmentId === input.routeThreadRef.environmentId &&    input.activeServerThread.id === input.targetThreadId,  );} export function buildThreadTurnInterruptInput(thread: Pick<Thread, "id" | "session">): {  threadId: ThreadId;  turnId?: TurnId;} {  const runningTurnId = thread.session?.status === "running" ? thread.session.activeTurnId : null;  return {    threadId: thread.id,    ...(runningTurnId !== null ? { turnId: runningTurnId } : {}),  };} export function reconcileMountedTerminalThreadIds(input: {  currentThreadIds: ReadonlyArray<string>;  openThreadIds: ReadonlyArray<string>;  activeThreadId: string | null;  activeThreadTerminalOpen: boolean;  maxHiddenThreadCount?: number;}): string[] {  return reconcileRetainedMountedThreadIds({    currentThreadIds: input.currentThreadIds,    openThreadIds: input.openThreadIds,    activeThreadId: input.activeThreadId,    activeThreadOpen: input.activeThreadTerminalOpen,    maxHiddenThreadCount: input.maxHiddenThreadCount ?? MAX_HIDDEN_MOUNTED_TERMINAL_THREADS,  });} export function reconcileRetainedMountedThreadIds(input: {  currentThreadIds: ReadonlyArray<string>;  openThreadIds: ReadonlyArray<string>;  activeThreadId: string | null;  activeThreadOpen: boolean;  maxHiddenThreadCount: number;  retainInactiveActiveThread?: boolean;}): string[] {  const openThreadIdSet = new Set(input.openThreadIds);  const hiddenThreadIds = input.currentThreadIds.filter(    (threadId) =>      (threadId !== input.activeThreadId || input.retainInactiveActiveThread === true) &&      openThreadIdSet.has(threadId),  );  const maxHiddenThreadCount = Math.max(0, input.maxHiddenThreadCount);  const nextThreadIds =    hiddenThreadIds.length > maxHiddenThreadCount      ? hiddenThreadIds.slice(-maxHiddenThreadCount)      : hiddenThreadIds;   if (    input.activeThreadId &&    input.activeThreadOpen &&    !nextThreadIds.includes(input.activeThreadId)  ) {    nextThreadIds.push(input.activeThreadId);  }   return nextThreadIds;} export function revokeBlobPreviewUrl(previewUrl: string | undefined): void {  if (!previewUrl || typeof URL === "undefined" || !previewUrl.startsWith("blob:")) {    return;  }  URL.revokeObjectURL(previewUrl);} export function revokeUserMessagePreviewUrls(message: ChatMessage): void {  if (message.role !== "user" || !message.attachments) {    return;  }  for (const attachment of message.attachments) {    if (attachment.type !== "image") {      continue;    }    revokeBlobPreviewUrl(attachment.previewUrl);  }} export function collectUserMessageBlobPreviewUrls(message: ChatMessage): string[] {  if (message.role !== "user" || !message.attachments) {    return [];  }  const previewUrls: string[] = [];  for (const attachment of message.attachments) {    if (attachment.type !== "image") continue;    if (!attachment.previewUrl || !attachment.previewUrl.startsWith("blob:")) continue;    previewUrls.push(attachment.previewUrl);  }  return previewUrls;} export interface PullRequestDialogState {  initialReference: string | null;  key: number;} export function readFileAsDataUrl(file: File): Promise<string> {  return new Promise((resolve, reject) => {    const reader = new FileReader();    reader.addEventListener("load", () => {      if (typeof reader.result === "string") {        resolve(reader.result);        return;      }      reject(new Error("Could not read image data."));    });    reader.addEventListener("error", () => {      reject(reader.error ?? new Error("Failed to read image."));    });    reader.readAsDataURL(file);  });} export function resolveSendEnvMode(input: {  requestedEnvMode: DraftThreadEnvMode;  isGitRepo: boolean;}): DraftThreadEnvMode {  return input.isGitRepo ? input.requestedEnvMode : "local";} export function resolveBackgroundDraftWorkspaceOptions(input: {  envMode: DraftThreadEnvMode;  branch: string | null;  startFromOrigin: boolean;}): {  envMode: DraftThreadEnvMode;  branch: string | null;  worktreePath: null;  startFromOrigin: boolean;} {  return {    envMode: input.envMode,    branch: input.branch,    worktreePath: null,    startFromOrigin: input.envMode === "worktree" && input.startFromOrigin,  };} export function cloneComposerImageForRetry(  image: ComposerImageAttachment,): ComposerImageAttachment {  if (typeof URL === "undefined" || !image.previewUrl.startsWith("blob:")) {    return image;  }  try {    return {      ...image,      previewUrl: URL.createObjectURL(image.file),    };  } catch {    return image;  }} export function deriveComposerSendState(options: {  prompt: string;  imageCount: number;  terminalContexts: ReadonlyArray<TerminalContextDraft>;  /**   * Optional element-pick attachment count. Element contexts contribute to   * "sendable content" exactly like images and (text-bearing) terminal   * contexts do: a prompt of just element chips is still a valid send.   */  elementContextCount?: number;}): {  trimmedPrompt: string;  sendableTerminalContexts: TerminalContextDraft[];  expiredTerminalContextCount: number;  hasSendableContent: boolean;} {  const trimmedPrompt = stripInlineTerminalContextPlaceholders(options.prompt).trim();  const sendableTerminalContexts = filterTerminalContextsWithText(options.terminalContexts);  const expiredTerminalContextCount =    options.terminalContexts.length - sendableTerminalContexts.length;  const elementContextCount = options.elementContextCount ?? 0;  return {    trimmedPrompt,    sendableTerminalContexts,    expiredTerminalContextCount,    hasSendableContent:      trimmedPrompt.length > 0 ||      options.imageCount > 0 ||      sendableTerminalContexts.length > 0 ||      elementContextCount > 0,  };} export function buildExpiredTerminalContextToastCopy(  expiredTerminalContextCount: number,  variant: "omitted" | "empty",): { title: string; description: string } {  const count = Math.max(1, Math.floor(expiredTerminalContextCount));  const noun = count === 1 ? "Expired terminal context" : "Expired terminal contexts";  if (variant === "empty") {    return {      title: `${noun} won't be sent`,      description: "Remove it or re-add it to include terminal output.",    };  }  return {    title: `${noun} omitted from message`,    description: "Re-add it if you want that terminal output included.",  };} export function branchMismatchKey(  threadId: string | null,  mismatch: { threadBranch: string; currentBranch: string } | null,): string | null {  if (!threadId || !mismatch) {    return null;  }  return `${threadId}:${mismatch.threadBranch}:${mismatch.currentBranch}`;} // The mismatch banner only matters when the user is about to send: passive// reading of an old thread carries no risk (the branch picker tint already// covers ambient awareness). Draft content is the intent signal — composer// focus is useless here because ChatView autofocuses the composer on every// thread open. `wasShownForCurrentMismatch` keeps the banner mounted once// revealed so it doesn't flicker away when the draft is cleared.export function shouldShowBranchMismatchBanner(input: {  hasMismatch: boolean;  isDismissed: boolean;  composerHasContent: boolean;  wasShownForCurrentMismatch: boolean;}): boolean {  if (!input.hasMismatch || input.isDismissed) {    return false;  }  return input.composerHasContent || input.wasShownForCurrentMismatch;} // Session-scoped (module-level so it survives ChatView remounts, e.g. route// changes). Durable cross-device dismissal is planned as a server-side ack.const sessionDismissedBranchMismatchKeys = new Set<string>(); export function dismissBranchMismatchForSession(key: string): void {  sessionDismissedBranchMismatchKeys.add(key);} export function isBranchMismatchDismissedForSession(key: string | null): boolean {  return key !== null && sessionDismissedBranchMismatchKeys.has(key);} export function threadHasStarted(thread: Thread | null | undefined): boolean {  return Boolean(    thread && (thread.latestTurn !== null || thread.messages.length > 0 || thread.session !== null),  );} // `threadProvider` is the open branded driver kind carried by the session.// Unknown driver kinds degrade to `null` (i.e. "unlocked"), which is the safe// rollback / fork behavior — the routing layer is the right place to surface// "driver not installed" errors, not the lock state.//// `selectedProvider` takes the same open-string shape because the composer// now tracks the picker selection as a `ProviderInstanceId` (e.g.// `codex_personal`). Custom instance ids that don't directly match a// registered driver resolve to `null` here, which matches the existing// "unknown driver -> unlocked" semantics. Callers that want the lock to track// a custom instance's underlying driver kind should resolve the instance id// upstream and pass the correlated kind.export function deriveLockedProvider(input: {  thread: Thread | null | undefined;  selectedProvider: string | null;  threadProvider: string | null;}): ProviderDriverKind | null {  if (!threadHasStarted(input.thread)) {    return null;  }  const sessionProvider = input.thread?.session?.providerName ?? null;  if (sessionProvider && isProviderDriverKind(sessionProvider)) {    return sessionProvider;  }  const narrowedThreadProvider =    input.threadProvider && isProviderDriverKind(input.threadProvider)      ? input.threadProvider      : null;  const narrowedSelectedProvider =    input.selectedProvider && isProviderDriverKind(input.selectedProvider)      ? input.selectedProvider      : null;  return narrowedThreadProvider ?? narrowedSelectedProvider ?? null;} export function getStartedThreadModelChangeBlockReason(input: {  providers: ReadonlyArray<Pick<ServerProvider, "instanceId" | "requiresNewThreadForModelChange">>;  hasStartedSession: boolean;  currentModelSelection: ModelSelection;  currentProviderInstanceId?: ModelSelection["instanceId"] | null | undefined;  nextModelSelection: ModelSelection;

Lines 1–500 of 674. Load more