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
| 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 | }); |