The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import { |
| 2 | scopedProjectKey, |
| 3 | scopeProjectRef, |
| 4 | scopeThreadRef, |
| 5 | } from "@t3tools/client-runtime/environment"; |
| 6 | import { DEFAULT_SERVER_SETTINGS, type ScopedProjectRef, type ThreadId } from "@t3tools/contracts"; |
| 7 | import { type AnyRouter, useRouter } from "@tanstack/react-router"; |
| 8 | import { |
| 9 | composerDraftHasUserContent, |
| 10 | markPromotedDraftThreadByRef, |
| 11 | type DraftId, |
| 12 | type DraftThreadEnvMode, |
| 13 | type DraftThreadState, |
| 14 | useComposerDraftStore, |
| 15 | } from "../composerDraftStore"; |
| 16 | import { newDraftId, newThreadId } from "../lib/utils"; |
| 17 | import { orderItemsByPreferredIds } from "../components/Sidebar.logic"; |
| 18 | import { |
| 19 | deriveLogicalProjectKeyFromSettings, |
| 20 | getProjectOrderKey, |
| 21 | selectProjectGroupingSettings, |
| 22 | } from "@t3tools/client-runtime/state/project-grouping"; |
| 23 | import { resolveNewThreadEnvMode, resolveProjectSettings } from "@t3tools/shared/projectSettings"; |
| 24 | import { |
| 25 | readProject, |
| 26 | readProjects, |
| 27 | readThreadShell, |
| 28 | readThreadShells, |
| 29 | useProjects, |
| 30 | useQuietThreadShell, |
| 31 | } from "../state/entities"; |
| 32 | import { |
| 33 | draftModelSelectionApplies, |
| 34 | hasExplicitComposerModelSelection, |
| 35 | resolveNewDraftStartFromOrigin, |
| 36 | resolveNewThreadModelSelectionOverride, |
| 37 | threadHasStarted, |
| 38 | } from "../lib/chatThreadActions"; |
| 39 | import type { EnvironmentProject } from "@t3tools/client-runtime/state/shell"; |
| 40 | import { readT3ProjectFile } from "../lib/t3ProjectFileDefaults"; |
| 41 | import { appAtomRegistry } from "../rpc/atomRegistry"; |
| 42 | import { environmentSummaries } from "../state/presentation"; |
| 43 | import { environmentServerConfigsAtom } from "../state/server"; |
| 44 | import { resolveThreadRouteTarget } from "../threadRoutes"; |
| 45 | import { legacyProjectCwdPreferenceKey, useUiStateStore } from "../uiStateStore"; |
| 46 | import { getClientSettings } from "./useSettings"; |
| 47 | import { getLocalStorageItem, useLocalStorage } from "./useLocalStorage"; |
| 48 | import * as Schema from "effect/Schema"; |
| 49 | import { useAtomValue } from "@effect/atom-react"; |
| 50 | import { defaultProjectFallbackReadyAtom } from "../state/projects"; |
| 51 | import { useThreadRouteTarget } from "./useThreadRouteTarget"; |
| 52 | import { readUnloadedThreadCount } from "../state/olderSettledShelf"; |
| 53 | import { resolveProjectDefaultProviderModelSelection } from "../providerInstances"; |
| 54 | import { resolveNewThreadModelSelection } from "@t3tools/shared/usageLimits"; |
| 55 | |
| 56 | export const LAST_USED_PROJECT_STORAGE_KEY = "t3code:last-used-project:v1"; |
| 57 | export const lastUsedProjectKeySchema = Schema.NullOr(Schema.String); |
| 58 | |
| 59 | export function readLastUsedProjectKey(): string | null { |
| 60 | try { |
| 61 | return getLocalStorageItem(LAST_USED_PROJECT_STORAGE_KEY, lastUsedProjectKeySchema); |
| 62 | } catch { |
| 63 | return null; |
| 64 | } |
| 65 | } |
| 66 | |
| 67 | interface NewThreadWorkspaceOptions { |
| 68 | branch?: string | null; |
| 69 | worktreePath?: string | null; |
| 70 | envMode?: DraftThreadEnvMode; |
| 71 | startFromOrigin?: boolean; |
| 72 | } |
| 73 | |
| 74 | function pickExplicitWorkspaceOptions(options: NewThreadWorkspaceOptions | undefined) { |
| 75 | return { |
| 76 | ...(options?.branch !== undefined ? { branch: options.branch } : {}), |
| 77 | ...(options?.worktreePath !== undefined ? { worktreePath: options.worktreePath } : {}), |
| 78 | ...(options?.envMode !== undefined ? { envMode: options.envMode } : {}), |
| 79 | ...(options?.startFromOrigin !== undefined ? { startFromOrigin: options.startFromOrigin } : {}), |
| 80 | }; |
| 81 | } |
| 82 | |
| 83 | export function useNewThreadHandler() { |
| 84 | return createNewThreadHandler(useRouter()); |
| 85 | } |
| 86 | |
| 87 | export type NewThreadHandler = ReturnType<typeof createNewThreadHandler>; |
| 88 | |
| 89 | export function createNewThreadHandler(router: AnyRouter) { |
| 90 | const getCurrentRouteTarget = () => { |
| 91 | const currentRouteParams = router.state.matches[router.state.matches.length - 1]?.params ?? {}; |
| 92 | return resolveThreadRouteTarget(currentRouteParams); |
| 93 | }; |
| 94 | |
| 95 | return ( |
| 96 | projectRef: ScopedProjectRef, |
| 97 | options?: { |
| 98 | branch?: string | null; |
| 99 | worktreePath?: string | null; |
| 100 | envMode?: DraftThreadEnvMode; |
| 101 | startFromOrigin?: boolean; |
| 102 | replace?: boolean; |
| 103 | /** Composer text for the draft, set before it shows. A draft with user text keeps it. */ |
| 104 | prompt?: string; |
| 105 | }, |
| 106 | ): Promise<{ draftId: DraftId; threadId: ThreadId } | null> => { |
| 107 | const projects = readProjects(); |
| 108 | const projectGroupingSettings = selectProjectGroupingSettings(getClientSettings()); |
| 109 | // Read at call time; status pushes replace the config map and would recreate every sidebar handler. |
| 110 | const environmentServerConfigs = appAtomRegistry.get(environmentServerConfigsAtom); |
| 111 | const targetServerSettings = |
| 112 | environmentServerConfigs.get(projectRef.environmentId)?.settings ?? DEFAULT_SERVER_SETTINGS; |
| 113 | const { |
| 114 | getComposerDraft, |
| 115 | getDraftSessionByLogicalProjectKey, |
| 116 | getDraftSession, |
| 117 | getDraftThread, |
| 118 | applyStickyState, |
| 119 | setDraftThreadContext, |
| 120 | setLogicalProjectDraftThreadId, |
| 121 | setModelSelection, |
| 122 | setPrompt, |
| 123 | } = useComposerDraftStore.getState(); |
| 124 | // Never over text the user wrote: a draft can gain some while this awaits. |
| 125 | const seedPrompt = (draftId: DraftId) => { |
| 126 | if (options?.prompt === undefined) return; |
| 127 | if (composerDraftHasUserContent(getComposerDraft(draftId))) return; |
| 128 | setPrompt(draftId, options.prompt); |
| 129 | }; |
| 130 | const requestingRouteHref = router.state.location.href; |
| 131 | const routeChangedSinceRequest = () => router.state.location.href !== requestingRouteHref; |
| 132 | const currentRouteTarget = getCurrentRouteTarget(); |
| 133 | const carrySourceShell = |
| 134 | currentRouteTarget?.kind === "server" ? readThreadShell(currentRouteTarget.threadRef) : null; |
| 135 | const carrySourceDraft = |
| 136 | currentRouteTarget?.kind === "draft" ? getDraftSession(currentRouteTarget.draftId) : null; |
| 137 | const carrySourceComposer = currentRouteTarget |
| 138 | ? getComposerDraft( |
| 139 | currentRouteTarget.kind === "server" |
| 140 | ? currentRouteTarget.threadRef |
| 141 | : currentRouteTarget.draftId, |
| 142 | ) |
| 143 | : null; |
| 144 | const composerActiveProvider = draftModelSelectionApplies( |
| 145 | carrySourceComposer, |
| 146 | threadHasStarted(carrySourceShell), |
| 147 | ) |
| 148 | ? (carrySourceComposer?.activeProvider ?? null) |
| 149 | : null; |
| 150 | const composerModelSelection = composerActiveProvider |
| 151 | ? (carrySourceComposer?.modelSelectionByProvider[composerActiveProvider] ?? null) |
| 152 | : null; |
| 153 | const carryModelSelection = composerModelSelection ?? carrySourceShell?.modelSelection ?? null; |
| 154 | const carryInteractionMode = |
| 155 | carrySourceComposer?.interactionMode ?? |
| 156 | carrySourceShell?.interactionMode ?? |
| 157 | carrySourceDraft?.interactionMode ?? |
| 158 | null; |
| 159 | const project = projects.find( |
| 160 | (candidate) => |
| 161 | candidate.id === projectRef.projectId && |
| 162 | candidate.environmentId === projectRef.environmentId, |
| 163 | ); |
| 164 | const abandonedSinceRequest = () => |
| 165 | routeChangedSinceRequest() || (project !== undefined && readProject(projectRef) === null); |
| 166 | const projectSettings = resolveProjectSettings( |
| 167 | targetServerSettings, |
| 168 | project?.id ?? null, |
| 169 | project, |
| 170 | ); |
| 171 | const configuredDefaultModelSelection = projectSettings.settings.defaultModelSelection ?? null; |
| 172 | const fallbackResolution = resolveNewThreadModelSelection({ |
| 173 | defaultSelection: |
| 174 | configuredDefaultModelSelection ?? |
| 175 | (carryModelSelection || useComposerDraftStore.getState().stickyActiveProvider !== null |
| 176 | ? null |
| 177 | : resolveProjectDefaultProviderModelSelection( |
| 178 | environmentServerConfigs.get(projectRef.environmentId)?.providers ?? [], |
| 179 | targetServerSettings, |
| 180 | projectRef.projectId, |
| 181 | )), |
| 182 | fallbackSelection: targetServerSettings.fallbackModelSelection ?? null, |
| 183 | providers: environmentServerConfigs.get(projectRef.environmentId)?.providers ?? [], |
| 184 | settings: targetServerSettings, |
| 185 | projectId: projectRef.projectId, |
| 186 | now: Date.now(), |
| 187 | }); |
| 188 | const projectDefaultModelSelection = fallbackResolution.fallback |
| 189 | ? fallbackResolution.selection |
| 190 | : configuredDefaultModelSelection; |
| 191 | const defaultRuntimeMode = projectSettings.settings.defaultRuntimeMode; |
| 192 | const resolveModelSelectionOverride = (destinationDraftId: DraftId) => |
| 193 | resolveNewThreadModelSelectionOverride({ |
| 194 | projectDefaultSelection: projectDefaultModelSelection ?? null, |
| 195 | carrySelection: carryModelSelection, |
| 196 | carrySourceDraftId: |
| 197 | currentRouteTarget?.kind === "draft" ? currentRouteTarget.draftId : null, |
| 198 | destinationDraftId, |
| 199 | }); |
| 200 | const resolveDefaultEnvMode = async (): Promise<DraftThreadEnvMode> => { |
| 201 | // Environment queries wait for a connection, so reading the project file on an |
| 202 | // offline machine would never settle and the draft would never open. |
| 203 | const consultProjectFile = |
| 204 | project !== undefined && |
| 205 | projectSettings.settings.defaultThreadEnvMode === null && |
| 206 | appAtomRegistry |
| 207 | .get(environmentSummaries.connectedEnvironmentIdsAtom) |
| 208 | .includes(project.environmentId); |
| 209 | const projectFile = consultProjectFile |
| 210 | ? await readT3ProjectFile(project.environmentId, project.workspaceRoot) |
| 211 | : null; |
| 212 | return resolveNewThreadEnvMode({ |
| 213 | projectSettings: resolveProjectSettings( |
| 214 | targetServerSettings, |
| 215 | project?.id ?? null, |
| 216 | project, |
| 217 | projectFile, |
| 218 | ), |
| 219 | workspaceRoot: project?.workspaceRoot ?? null, |
| 220 | newProjectsRoot: environmentServerConfigs.get(projectRef.environmentId)?.newProjectsRoot, |
| 221 | projectHasThreads: |
| 222 | readThreadShells().some( |
| 223 | (thread) => |
| 224 | thread.environmentId === projectRef.environmentId && |
| 225 | thread.projectId === projectRef.projectId, |
| 226 | ) || |
| 227 | readUnloadedThreadCount( |
| 228 | [{ environmentId: projectRef.environmentId, id: projectRef.projectId }], |
| 229 | [], |
| 230 | ) > 0, |
| 231 | }); |
| 232 | }; |
| 233 | const logicalProjectKey = project |
| 234 | ? deriveLogicalProjectKeyFromSettings(project, projectGroupingSettings) |
| 235 | : scopedProjectKey(projectRef); |
| 236 | // Another opener (home's own first-project draft) may have reached this project's draft first. |
| 237 | // Matches lag the location during a navigation, so compare against the location. |
| 238 | const resultIfAbandoned = () => { |
| 239 | const draft = getDraftSessionByLogicalProjectKey(logicalProjectKey); |
| 240 | if (draft === null || draft.promotedTo != null || readProject(projectRef) === null) { |
| 241 | return null; |
| 242 | } |
| 243 | const draftHref = router.buildLocation({ |
| 244 | to: "/draft/$draftId", |
| 245 | params: { draftId: draft.draftId }, |
| 246 | }).href; |
| 247 | return router.state.location.href === draftHref |
| 248 | ? { draftId: draft.draftId, threadId: draft.threadId } |
| 249 | : null; |
| 250 | }; |
| 251 | const hasBranchOption = options?.branch !== undefined; |
| 252 | const hasWorktreePathOption = options?.worktreePath !== undefined; |
| 253 | const hasEnvModeOption = options?.envMode !== undefined; |
| 254 | const hasStartFromOriginOption = options?.startFromOrigin !== undefined; |
| 255 | const storedDraftThread = getDraftSessionByLogicalProjectKey(logicalProjectKey); |
| 256 | const storedDraftThreadRef = storedDraftThread |
| 257 | ? scopeThreadRef(storedDraftThread.environmentId, storedDraftThread.threadId) |
| 258 | : null; |
| 259 | const reusableStoredDraftThread = |
| 260 | storedDraftThread !== null && |
| 261 | storedDraftThread.promotedTo == null && |
| 262 | storedDraftThreadRef !== null && |
| 263 | readThreadShell(storedDraftThreadRef) === null |
| 264 | ? storedDraftThread |
| 265 | : null; |
| 266 | if (storedDraftThreadRef && reusableStoredDraftThread === null) { |
| 267 | markPromotedDraftThreadByRef(storedDraftThreadRef); |
| 268 | } |
| 269 | const emptyStoredDraftThread = |
| 270 | reusableStoredDraftThread && |
| 271 | !composerDraftHasUserContent(getComposerDraft(reusableStoredDraftThread.draftId)) |
| 272 | ? reusableStoredDraftThread |
| 273 | : null; |
| 274 | const latestActiveDraftThread: DraftThreadState | null = currentRouteTarget |
| 275 | ? currentRouteTarget.kind === "server" |
| 276 | ? getDraftThread(currentRouteTarget.threadRef) |
| 277 | : getDraftSession(currentRouteTarget.draftId) |
| 278 | : null; |
| 279 | if (emptyStoredDraftThread) { |
| 280 | return (async () => { |
| 281 | const isDraftAlreadyOpen = |
| 282 | currentRouteTarget?.kind === "draft" && |
| 283 | currentRouteTarget.draftId === emptyStoredDraftThread.draftId; |
| 284 | const hasExplicitWorkspaceOption = |
| 285 | hasBranchOption || hasWorktreePathOption || hasEnvModeOption || hasStartFromOriginOption; |
| 286 | let workspaceContext: NewThreadWorkspaceOptions | null = null; |
| 287 | if (hasExplicitWorkspaceOption) { |
| 288 | workspaceContext = pickExplicitWorkspaceOptions(options); |
| 289 | } else if (!isDraftAlreadyOpen) { |
| 290 | const defaultEnvMode = await resolveDefaultEnvMode(); |
| 291 | if (abandonedSinceRequest()) { |
| 292 | return resultIfAbandoned(); |
| 293 | } |
| 294 | // Concurrent calls may change the draft; stale resets, remaps, or navigation could clobber it. |
| 295 | const routeTargetNow = getCurrentRouteTarget(); |
| 296 | const openedMeanwhile = |
| 297 | routeTargetNow?.kind === "draft" && |
| 298 | routeTargetNow.draftId === emptyStoredDraftThread.draftId; |
| 299 | const promotedMeanwhile = |
| 300 | storedDraftThreadRef !== null && readThreadShell(storedDraftThreadRef) !== null; |
| 301 | const remappedMeanwhile = |
| 302 | getDraftSessionByLogicalProjectKey(logicalProjectKey)?.draftId !== |
| 303 | emptyStoredDraftThread.draftId; |
| 304 | const investedMeanwhile = composerDraftHasUserContent( |
| 305 | getComposerDraft(emptyStoredDraftThread.draftId), |
| 306 | ); |
| 307 | if (openedMeanwhile || promotedMeanwhile || remappedMeanwhile || investedMeanwhile) { |
| 308 | return null; |
| 309 | } |
| 310 | workspaceContext = { |
| 311 | branch: null, |
| 312 | worktreePath: null, |
| 313 | envMode: defaultEnvMode, |
| 314 | startFromOrigin: resolveNewDraftStartFromOrigin({ |
| 315 | envMode: defaultEnvMode, |
| 316 | newWorktreesStartFromOrigin: projectSettings.settings.newWorktreesStartFromOrigin, |
| 317 | }), |
| 318 | }; |
| 319 | } |
| 320 | if (workspaceContext) { |
| 321 | setDraftThreadContext(emptyStoredDraftThread.draftId, { |
| 322 | ...workspaceContext, |
| 323 | ...(!isDraftAlreadyOpen ? { runtimeMode: defaultRuntimeMode } : {}), |
| 324 | ...(carryInteractionMode ? { interactionMode: carryInteractionMode } : {}), |
| 325 | }); |
| 326 | } |
| 327 | const storedDraft = getComposerDraft(emptyStoredDraftThread.draftId); |
| 328 | const storedDraftHasExplicitModelPick = hasExplicitComposerModelSelection(storedDraft); |
| 329 | if (!storedDraftHasExplicitModelPick) { |
| 330 | applyStickyState(emptyStoredDraftThread.draftId); |
| 331 | const modelSelectionOverride = resolveModelSelectionOverride( |
| 332 | emptyStoredDraftThread.draftId, |
| 333 | ); |
| 334 | if (modelSelectionOverride) { |
| 335 | setModelSelection(emptyStoredDraftThread.draftId, modelSelectionOverride, { |
| 336 | replaceOptions: true, |
| 337 | }); |
| 338 | } |
| 339 | } |
| 340 | // Remapping physical projects clears workspace context; preserve the branch and worktree. |
| 341 | setLogicalProjectDraftThreadId( |
| 342 | logicalProjectKey, |
| 343 | projectRef, |
| 344 | emptyStoredDraftThread.draftId, |
| 345 | { |
| 346 | threadId: emptyStoredDraftThread.threadId, |
| 347 | ...workspaceContext, |
| 348 | ...(!isDraftAlreadyOpen ? { runtimeMode: defaultRuntimeMode } : {}), |
| 349 | ...(carryInteractionMode ? { interactionMode: carryInteractionMode } : {}), |
| 350 | }, |
| 351 | ); |
| 352 | const opened = { |
| 353 | draftId: emptyStoredDraftThread.draftId, |
| 354 | threadId: emptyStoredDraftThread.threadId, |
| 355 | }; |
| 356 | seedPrompt(emptyStoredDraftThread.draftId); |
| 357 | const routeTargetAfterWrites = getCurrentRouteTarget(); |
| 358 | if ( |
| 359 | routeTargetAfterWrites?.kind === "draft" && |
| 360 | routeTargetAfterWrites.draftId === emptyStoredDraftThread.draftId |
| 361 | ) { |
| 362 | return opened; |
| 363 | } |
| 364 | await router.navigate({ |
| 365 | to: "/draft/$draftId", |
| 366 | params: { draftId: emptyStoredDraftThread.draftId }, |
| 367 | replace: options?.replace ?? false, |
| 368 | }); |
| 369 | return opened; |
| 370 | })(); |
| 371 | } |
| 372 | |
| 373 | if ( |
| 374 | latestActiveDraftThread && |
| 375 | currentRouteTarget?.kind === "draft" && |
| 376 | latestActiveDraftThread.logicalProjectKey === logicalProjectKey && |
| 377 | latestActiveDraftThread.promotedTo == null && |
| 378 | !composerDraftHasUserContent(getComposerDraft(currentRouteTarget.draftId)) |
| 379 | ) { |
| 380 | if ( |
| 381 | hasBranchOption || |
| 382 | hasWorktreePathOption || |
| 383 | hasEnvModeOption || |
| 384 | hasStartFromOriginOption |
| 385 | ) { |
| 386 | setDraftThreadContext(currentRouteTarget.draftId, pickExplicitWorkspaceOptions(options)); |
| 387 | } |
| 388 | setLogicalProjectDraftThreadId(logicalProjectKey, projectRef, currentRouteTarget.draftId, { |
| 389 | threadId: latestActiveDraftThread.threadId, |
| 390 | createdAt: latestActiveDraftThread.createdAt, |
| 391 | runtimeMode: latestActiveDraftThread.runtimeMode, |
| 392 | interactionMode: latestActiveDraftThread.interactionMode, |
| 393 | ...pickExplicitWorkspaceOptions(options), |
| 394 | }); |
| 395 | seedPrompt(currentRouteTarget.draftId); |
| 396 | return Promise.resolve({ |
| 397 | draftId: currentRouteTarget.draftId, |
| 398 | threadId: latestActiveDraftThread.threadId, |
| 399 | }); |
| 400 | } |
| 401 | |
| 402 | const draftId = newDraftId(); |
| 403 | const threadId = newThreadId(); |
| 404 | const createdAt = new Date().toISOString(); |
| 405 | return (async () => { |
| 406 | const initialEnvMode = options?.envMode ?? (await resolveDefaultEnvMode()); |
| 407 | if (abandonedSinceRequest()) { |
| 408 | return resultIfAbandoned(); |
| 409 | } |
| 410 | // Reuse drafts registered while awaiting so their pending navigation cannot lose them. |
| 411 | const racedDraft = getDraftSessionByLogicalProjectKey(logicalProjectKey); |
| 412 | if ( |
| 413 | racedDraft && |
| 414 | racedDraft.draftId !== storedDraftThread?.draftId && |
| 415 | readThreadShell(scopeThreadRef(racedDraft.environmentId, racedDraft.threadId)) === null |
| 416 | ) { |
| 417 | setLogicalProjectDraftThreadId(logicalProjectKey, projectRef, racedDraft.draftId, { |
| 418 | threadId: racedDraft.threadId, |
| 419 | createdAt: racedDraft.createdAt, |
| 420 | runtimeMode: racedDraft.runtimeMode, |
| 421 | interactionMode: racedDraft.interactionMode, |
| 422 | ...pickExplicitWorkspaceOptions(options), |
| 423 | }); |
| 424 | seedPrompt(racedDraft.draftId); |
| 425 | await router.navigate({ |
| 426 | to: "/draft/$draftId", |
| 427 | params: { draftId: racedDraft.draftId }, |
| 428 | replace: options?.replace ?? false, |
| 429 | }); |
| 430 | return { draftId: racedDraft.draftId, threadId: racedDraft.threadId }; |
| 431 | } |
| 432 | setLogicalProjectDraftThreadId(logicalProjectKey, projectRef, draftId, { |
| 433 | threadId, |
| 434 | createdAt, |
| 435 | branch: options?.branch ?? null, |
| 436 | worktreePath: options?.worktreePath ?? null, |
| 437 | envMode: initialEnvMode, |
| 438 | startFromOrigin: |
| 439 | options?.startFromOrigin ?? |
| 440 | resolveNewDraftStartFromOrigin({ |
| 441 | envMode: initialEnvMode, |
| 442 | newWorktreesStartFromOrigin: projectSettings.settings.newWorktreesStartFromOrigin, |
| 443 | }), |
| 444 | runtimeMode: defaultRuntimeMode, |
| 445 | ...(carryInteractionMode ? { interactionMode: carryInteractionMode } : {}), |
| 446 | }); |
| 447 | applyStickyState(draftId); |
| 448 | const modelSelectionOverride = resolveModelSelectionOverride(draftId); |
| 449 | if (modelSelectionOverride) { |
| 450 | setModelSelection(draftId, modelSelectionOverride, { replaceOptions: true }); |
| 451 | } |
| 452 | seedPrompt(draftId); |
| 453 | await router.navigate({ |
| 454 | to: "/draft/$draftId", |
| 455 | params: { draftId }, |
| 456 | replace: options?.replace ?? false, |
| 457 | }); |
| 458 | return { draftId, threadId }; |
| 459 | })(); |
| 460 | }; |
| 461 | } |
| 462 | |
| 463 | export function resolveDefaultProjectRef( |
| 464 | projects: ReadonlyArray<EnvironmentProject>, |
| 465 | projectOrder: readonly string[], |
| 466 | lastUsedProjectKey: string | null, |
| 467 | fallbackReady = true, |
| 468 | ): ScopedProjectRef | null { |
| 469 | const lastUsed = projects.find( |
| 470 | (project) => |
| 471 | project.archivedAt == null && |
| 472 | scopedProjectKey(scopeProjectRef(project.environmentId, project.id)) === lastUsedProjectKey, |
| 473 | ); |
| 474 | if (lastUsed) return scopeProjectRef(lastUsed.environmentId, lastUsed.id); |
| 475 | if (!fallbackReady) return null; |
| 476 | const [defaultProject] = orderItemsByPreferredIds({ |
| 477 | items: projects.filter((project) => project.archivedAt == null), |
| 478 | preferredIds: projectOrder, |
| 479 | getId: getProjectOrderKey, |
| 480 | getPreferenceIds: (project) => [ |
| 481 | getProjectOrderKey(project), |
| 482 | legacyProjectCwdPreferenceKey(project.workspaceRoot), |
| 483 | ], |
| 484 | }); |
| 485 | return defaultProject ? scopeProjectRef(defaultProject.environmentId, defaultProject.id) : null; |
| 486 | } |
| 487 | |
| 488 | export function useHandleNewThread() { |
| 489 | const projectOrder = useUiStateStore((store) => store.projectOrder); |
| 490 | const [lastUsedProjectKey] = useLocalStorage( |
| 491 | LAST_USED_PROJECT_STORAGE_KEY, |
| 492 | null, |
| 493 | lastUsedProjectKeySchema, |
| 494 | ); |
| 495 | const defaultProjectFallbackReady = useAtomValue( |
| 496 | defaultProjectFallbackReadyAtom(lastUsedProjectKey), |
| 497 | ); |
| 498 | const routeTarget = useThreadRouteTarget(); |
| 499 | const routeThreadRef = routeTarget?.kind === "server" ? routeTarget.threadRef : null; |
| 500 | const routeDraftId = routeTarget?.kind === "draft" ? routeTarget.draftId : null; |
| 501 | const activeThread = useQuietThreadShell(routeThreadRef); |
| 502 | const getDraftThread = useComposerDraftStore((store) => store.getDraftThread); |
| 503 | const activeDraftThread = useComposerDraftStore(() => |
| 504 | routeTarget |
| 505 | ? routeTarget.kind === "server" |
| 506 | ? getDraftThread(routeTarget.threadRef) |
| 507 | : useComposerDraftStore.getState().getDraftSession(routeTarget.draftId) |
| 508 | : null, |
| 509 | ); |
| 510 | const projects = useProjects(); |
| 511 | const handleNewThread = useNewThreadHandler(); |
| 512 | const defaultProjectRef = resolveDefaultProjectRef( |
| 513 | projects, |
| 514 | projectOrder, |
| 515 | lastUsedProjectKey, |
| 516 | defaultProjectFallbackReady, |
| 517 | ); |
| 518 | |
| 519 | return { |
| 520 | activeDraftThread, |
| 521 | activeThread, |
| 522 | defaultProjectRef, |
| 523 | defaultProjectFallbackReady, |
| 524 | handleNewThread, |
| 525 | routeDraftId, |
| 526 | routeThreadRef, |
| 527 | }; |
| 528 | } |