@devries-cameron20 / t3code Mirror · read-only
Fork 0

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

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 438 lines 14.9 KB
Raw
1 import { describe, expect, it, vi } from "vite-plus/test";
2 import type { EnvironmentId, ProjectId, RuntimeMode } from "@t3tools/contracts";
3
4 const testState = vi.hoisted(() => {
5 let completeProjectFileRead: (value: null) => void = () => undefined;
6 let projectFileRead = Promise.resolve<null>(null);
7 let projectRemoved = false;
8 let connectedEnvironmentIds = ["environment-primary", "environment-ssh"];
9 let targetSettings = {
10 defaultThreadEnvMode: "local" as "local" | "worktree" | null,
11 newWorktreesStartFromOrigin: false,
12 defaultModelSelection: null,
13 defaultRuntimeMode: "full-access" as RuntimeMode,
14 };
15 let storedDraft: {
16 readonly draftId: string;
17 readonly environmentId: string;
18 readonly promotedTo: null;
19 readonly threadId: string;
20 } | null = null;
21 let openDraftRoute: { readonly kind: "draft"; readonly draftId: string } | null = null;
22 let draftsWithUserText = new Set<string>();
23 const router = {
24 state: {
25 location: { href: "/" },
26 matches: [{ params: {} }],
27 },
28 navigate: vi.fn(async (request: { readonly params: { readonly draftId: string } }) => {
29 router.state.location.href = `/draft/${request.params.draftId}`;
30 }),
31 buildLocation: (request: { readonly params: { readonly draftId: string } }) => ({
32 href: `/draft/${request.params.draftId}`,
33 }),
34 };
35 const draftStore = {
36 getComposerDraft: vi.fn((draftId: string) => ({ draftId })),
37 getDraftSessionByLogicalProjectKey: vi.fn(() => storedDraft),
38 getDraftSession: vi.fn(() =>
39 openDraftRoute === null
40 ? null
41 : {
42 logicalProjectKey: "remote-project",
43 promotedTo: null,
44 threadId: "thread-open",
45 createdAt: "2026-01-01T00:00:00.000Z",
46 runtimeMode: "full-access",
47 interactionMode: "default",
48 },
49 ),
50 getDraftThread: vi.fn(() => null),
51 applyStickyState: vi.fn(),
52 setDraftThreadContext: vi.fn(),
53 setLogicalProjectDraftThreadId: vi.fn(),
54 setModelSelection: vi.fn(),
55 setPrompt: vi.fn(),
56 };
57
58 return {
59 completeProjectFileRead: (value: null) => completeProjectFileRead(value),
60 draftStore,
61 get projectFileRead() {
62 return projectFileRead;
63 },
64 get projectRemoved() {
65 return projectRemoved;
66 },
67 get connectedEnvironmentIds() {
68 return connectedEnvironmentIds;
69 },
70 disconnect(environmentId: string) {
71 connectedEnvironmentIds = connectedEnvironmentIds.filter((id) => id !== environmentId);
72 },
73 removeProject() {
74 projectRemoved = true;
75 },
76 hasUserText: (draft: { readonly draftId?: string } | null | undefined) =>
77 draft?.draftId !== undefined && draftsWithUserText.has(draft.draftId),
78 giveUserText(draftId: string) {
79 draftsWithUserText = new Set([...draftsWithUserText, draftId]);
80 },
81 get openDraftRoute() {
82 return openDraftRoute;
83 },
84 registerDraft(draft: NonNullable<typeof storedDraft>) {
85 storedDraft = draft;
86 },
87 openEmptyDraft(draftId: string) {
88 openDraftRoute = { kind: "draft", draftId };
89 },
90 get targetSettings() {
91 return targetSettings;
92 },
93 reset(
94 nextStoredDraft: typeof storedDraft,
95 workspaceDefaults = {
96 envMode: "local" as "local" | "worktree" | null,
97 startFromOrigin: false,
98 },
99 ) {
100 storedDraft = nextStoredDraft;
101 openDraftRoute = null;
102 draftsWithUserText = new Set();
103 projectRemoved = false;
104 connectedEnvironmentIds = ["environment-primary", "environment-ssh"];
105 targetSettings = {
106 defaultThreadEnvMode: workspaceDefaults.envMode,
107 newWorktreesStartFromOrigin: workspaceDefaults.startFromOrigin,
108 defaultModelSelection: null,
109 defaultRuntimeMode: "full-access",
110 };
111 router.state.location.href = "/";
112 router.navigate.mockClear();
113 draftStore.setDraftThreadContext.mockClear();
114 draftStore.setLogicalProjectDraftThreadId.mockClear();
115 draftStore.setPrompt.mockClear();
116 projectFileRead = new Promise<null>((resolve) => {
117 completeProjectFileRead = resolve;
118 });
119 },
120 router,
121 };
122 });
123
124 const testServerConfigs = () =>
125 new Map([
126 [
127 "environment-primary",
128 {
129 settings: {
130 ...testState.targetSettings,
131 newWorktreesStartFromOrigin: !testState.targetSettings.newWorktreesStartFromOrigin,
132 },
133 },
134 ],
135 ["environment-ssh", { settings: testState.targetSettings }],
136 ]);
137
138 vi.mock("../rpc/atomRegistry", () => ({
139 appAtomRegistry: {
140 get: (atom: unknown) =>
141 atom === "connected-environment-ids"
142 ? testState.connectedEnvironmentIds
143 : testServerConfigs(),
144 },
145 }));
146
147 vi.mock("@effect/atom-react", () => ({
148 useAtomValue: (atom: unknown) =>
149 atom === "primary-settings"
150 ? { newWorktreesStartFromOrigin: !testState.targetSettings.newWorktreesStartFromOrigin }
151 : testServerConfigs(),
152 }));
153 vi.mock("@t3tools/client-runtime/environment", () => ({
154 scopedProjectKey: (ref: { environmentId: string; projectId: string }) =>
155 `${ref.environmentId}:${ref.projectId}`,
156 scopeProjectRef: (environmentId: string, projectId: string) => ({ environmentId, projectId }),
157 scopeThreadRef: (environmentId: string, threadId: string) => ({ environmentId, threadId }),
158 }));
159 vi.mock("@t3tools/contracts", () => ({
160 DEFAULT_RUNTIME_MODE: "default",
161 DEFAULT_SERVER_SETTINGS: {},
162 }));
163 vi.mock("@t3tools/shared/projectSettings", () => ({
164 resolveProjectSettings: (
165 settings: Record<string, unknown>,
166 _projectId: unknown,
167 _project: unknown,
168 projectFile?: { defaultThreadEnvMode?: "local" | "worktree" } | null,
169 ) => ({
170 settings:
171 projectFile === undefined
172 ? settings
173 : {
174 ...settings,
175 defaultThreadEnvMode:
176 settings.defaultThreadEnvMode ?? projectFile?.defaultThreadEnvMode ?? "local",
177 },
178 sources: { defaultModelSelection: "environment", defaultThreadEnvMode: "environment" },
179 overrides: {},
180 }),
181 resolveNewThreadEnvMode: (input: {
182 projectSettings: { settings: { defaultThreadEnvMode: "local" | "worktree" } };
183 }) => input.projectSettings.settings.defaultThreadEnvMode,
184 }));
185 vi.mock("@tanstack/react-router", () => ({
186 useParams: () => null,
187 useRouter: () => testState.router,
188 }));
189 vi.mock("react", () => ({
190 useCallback: <T>(callback: T) => callback,
191 useMemo: <T>(factory: () => T) => factory(),
192 }));
193 vi.mock("../components/Sidebar.logic", () => ({
194 orderItemsByPreferredIds: ({ items }: { items: unknown[] }) => items,
195 }));
196 vi.mock("../composerDraftStore", () => {
197 const useComposerDraftStore = Object.assign(() => null, {
198 getState: () => testState.draftStore,
199 });
200 return {
201 composerDraftHasUserContent: (draft: { readonly draftId?: string } | null | undefined) =>
202 testState.hasUserText(draft),
203 markPromotedDraftThreadByRef: vi.fn(),
204 useComposerDraftStore,
205 };
206 });
207 vi.mock("../lib/chatThreadActions", async (importOriginal) => ({
208 ...(await importOriginal<typeof import("../lib/chatThreadActions")>()),
209 hasExplicitComposerModelSelection: () => false,
210 resolveNewThreadModelSelectionOverride: () => null,
211 }));
212 vi.mock("../providerInstances", () => ({ resolveDefaultProviderModelSelection: () => null }));
213 vi.mock("../lib/t3ProjectFileDefaults", () => ({
214 readT3ProjectFile: () => testState.projectFileRead,
215 }));
216 vi.mock("../lib/utils", () => ({
217 newDraftId: () => "draft-delayed",
218 newThreadId: () => "thread-delayed",
219 }));
220 vi.mock("@t3tools/client-runtime/state/project-grouping", () => ({
221 deriveLogicalProjectKeyFromSettings: () => "remote-project",
222 getProjectOrderKey: () => "remote-project",
223 selectProjectGroupingSettings: () => ({}),
224 }));
225 vi.mock("../state/entities", () => {
226 const project = {
227 id: "project-remote",
228 environmentId: "environment-ssh",
229 workspaceRoot: "/remote/project",
230 defaultThreadEnvMode: null,
231 defaultModelSelection: null,
232 };
233 return {
234 readProject: () => (testState.projectRemoved ? null : project),
235 readProjects: () => (testState.projectRemoved ? [] : [project]),
236 readThreadShell: () => null,
237 readThreadShells: () => [],
238 useProjects: () => [],
239 useThread: () => null,
240 };
241 });
242 vi.mock("../state/projects", () => ({ defaultProjectFallbackReadyAtom: () => true }));
243 vi.mock("../state/olderSettledShelf", () => ({ readUnloadedThreadCount: () => 0 }));
244 vi.mock("../state/presentation", () => ({
245 environmentSummaries: { connectedEnvironmentIdsAtom: "connected-environment-ids" },
246 }));
247 vi.mock("../state/server", () => ({
248 environmentServerConfigsAtom: {},
249 primaryServerSettingsAtom: "primary-settings",
250 }));
251 vi.mock("../threadRoutes", () => ({
252 resolveThreadRouteTarget: () => testState.openDraftRoute,
253 }));
254 vi.mock("../uiStateStore", () => ({
255 legacyProjectCwdPreferenceKey: () => "remote-project",
256 useUiStateStore: () => [],
257 }));
258 vi.mock("./useSettings", () => ({ getClientSettings: () => ({}) }));
259
260 import { resolveDefaultProjectRef, useNewThreadHandler } from "./useHandleNewThread";
261
262 describe.each([
263 ["new", null],
264 [
265 "reusable",
266 {
267 draftId: "draft-existing",
268 environmentId: "environment-ssh",
269 promotedTo: null,
270 threadId: "thread-existing",
271 },
272 ],
273 ])("useNewThreadHandler with a %s draft", (_, draft) => {
274 it("abandons a delayed draft open when the user navigates elsewhere", async () => {
275 testState.reset(draft);
276 const openThread = useNewThreadHandler();
277 const pendingOpen = openThread(
278 { environmentId: "environment-ssh", projectId: "project-remote" } as never,
279 { replace: true },
280 );
281
282 testState.router.state.location.href = "/usage";
283 testState.completeProjectFileRead(null);
284 await pendingOpen;
285
286 expect(testState.router.state.location.href).toBe("/usage");
287 expect(testState.router.navigate).not.toHaveBeenCalled();
288 expect(testState.draftStore.setLogicalProjectDraftThreadId).not.toHaveBeenCalled();
289 });
290
291 it("resolves to the draft another opener showed for the same project meanwhile", async () => {
292 testState.reset(draft);
293 const pendingOpen = useNewThreadHandler()(
294 { environmentId: "environment-ssh", projectId: "project-remote" } as never,
295 { replace: true },
296 );
297
298 // The location moves before the route matches do.
299 testState.registerDraft({
300 draftId: "draft-home",
301 environmentId: "environment-ssh",
302 promotedTo: null,
303 threadId: "thread-home",
304 });
305 testState.router.state.location.href = "/draft/draft-home";
306 testState.completeProjectFileRead(null);
307
308 await expect(pendingOpen).resolves.toEqual({
309 draftId: "draft-home",
310 threadId: "thread-home",
311 });
312 expect(testState.router.navigate).not.toHaveBeenCalled();
313 expect(testState.draftStore.setLogicalProjectDraftThreadId).not.toHaveBeenCalled();
314 });
315
316 it("sets the prompt before the draft shows", async () => {
317 testState.reset(draft);
318 const pendingOpen = useNewThreadHandler()(
319 { environmentId: "environment-ssh", projectId: "project-remote" } as never,
320 { prompt: "Read the playbook. " },
321 );
322
323 testState.completeProjectFileRead(null);
324 const opened = await pendingOpen;
325
326 expect(testState.draftStore.setPrompt).toHaveBeenCalledWith(
327 opened?.draftId,
328 "Read the playbook. ",
329 );
330 expect(testState.draftStore.setPrompt.mock.invocationCallOrder[0]).toBeLessThan(
331 testState.router.navigate.mock.invocationCallOrder[0] ?? 0,
332 );
333 });
334
335 it("abandons a delayed draft open when the project is removed meanwhile", async () => {
336 testState.reset(draft);
337 const pendingOpen = useNewThreadHandler()(
338 { environmentId: "environment-ssh", projectId: "project-remote" } as never,
339 { replace: true },
340 );
341
342 testState.removeProject();
343 testState.completeProjectFileRead(null);
344
345 await expect(pendingOpen).resolves.toBeNull();
346 expect(testState.router.navigate).not.toHaveBeenCalled();
347 expect(testState.draftStore.setLogicalProjectDraftThreadId).not.toHaveBeenCalled();
348 });
349 });
350
351 describe("useNewThreadHandler", () => {
352 it("keeps the text of a draft that gained some while it waited", async () => {
353 testState.reset(null);
354 const raced = {
355 draftId: "draft-raced",
356 environmentId: "environment-ssh",
357 promotedTo: null,
358 threadId: "thread-raced",
359 };
360 testState.draftStore.getDraftSessionByLogicalProjectKey
361 .mockReturnValueOnce(null)
362 .mockReturnValueOnce(raced as never);
363 testState.giveUserText("draft-raced");
364
365 const opened = await useNewThreadHandler()(
366 { environmentId: "environment-ssh", projectId: "project-remote" } as never,
367 { prompt: "Read the playbook. " },
368 );
369
370 expect(opened?.draftId).toBe("draft-raced");
371 expect(testState.draftStore.setPrompt).not.toHaveBeenCalled();
372 });
373
374 it("seeds the prompt into the empty draft that is already open", async () => {
375 testState.reset(null);
376 testState.openEmptyDraft("draft-open");
377
378 const opened = await useNewThreadHandler()(
379 { environmentId: "environment-ssh", projectId: "project-remote" } as never,
380 { prompt: "Read the playbook. " },
381 );
382
383 expect(opened?.draftId).toBe("draft-open");
384 expect(testState.draftStore.setPrompt).toHaveBeenCalledWith(
385 "draft-open",
386 "Read the playbook. ",
387 );
388 });
389
390 it("opens the draft without waiting on a project file from an offline machine", async () => {
391 testState.reset(null, { envMode: null, startFromOrigin: false });
392 testState.disconnect("environment-ssh");
393
394 const opened = await useNewThreadHandler()({
395 environmentId: "environment-ssh",
396 projectId: "project-remote",
397 } as never);
398
399 expect(opened).toEqual({ draftId: "draft-delayed", threadId: "thread-delayed" });
400 expect(testState.router.navigate).toHaveBeenCalledOnce();
401 });
402 });
403
404 describe("default project selection", () => {
405 it("prefers the last used project in its environment and falls back when unavailable", () => {
406 const projects = [
407 { id: "project", environmentId: "first", workspaceRoot: "/first" },
408 { id: "project", environmentId: "last-used", workspaceRoot: "/last-used" },
409 ].map((project) => ({
410 ...project,
411 id: project.id as ProjectId,
412 environmentId: project.environmentId as EnvironmentId,
413 title: project.environmentId,
414 defaultModelSelection: null,
415 scripts: [],
416 createdAt: "2026-11-09T00:00:00.000Z",
417 updatedAt: "2026-11-09T00:00:00.000Z",
418 }));
419 expect(resolveDefaultProjectRef(projects, [], "last-used:project")).toEqual({
420 environmentId: "last-used",
421 projectId: "project",
422 });
423 expect(
424 resolveDefaultProjectRef(projects.slice(0, 1), [], "last-used:project", false),
425 ).toBeNull();
426 expect(resolveDefaultProjectRef(projects.slice(0, 1), [], "last-used:project")).toEqual({
427 environmentId: "first",
428 projectId: "project",
429 });
430 expect(
431 resolveDefaultProjectRef(
432 [projects[0]!, { ...projects[1]!, archivedAt: "2026-11-09T00:00:00.000Z" }],
433 [],
434 "last-used:project",
435 ),
436 ).toEqual({ environmentId: "first", projectId: "project" });
437 });
438 });