The best way to control Claude Code, Codex and more from any computer or phone

main
ts 528 lines 21.4 KB
Raw
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 }