The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import { ProjectId, ThreadId, type ThreadPullRequestLink } from "@t3tools/contracts"; |
| 2 | import { describe, expect, it } from "vite-plus/test"; |
| 3 | |
| 4 | import { v2Project, v2ShellSnapshot, v2ThreadShell } from "./orchestrationV2TestFixtures.ts"; |
| 5 | import { |
| 6 | applyShellStreamEvent, |
| 7 | applyShellStreamEvents, |
| 8 | type ShellStreamEvent, |
| 9 | mergeShellSnapshotProjects, |
| 10 | reuseUnchangedThreadShells, |
| 11 | } from "./shellReducer.ts"; |
| 12 | |
| 13 | const repositoryIdentity = { |
| 14 | canonicalKey: "github.com/example/repo", |
| 15 | locator: { |
| 16 | source: "git-remote" as const, |
| 17 | remoteName: "origin", |
| 18 | remoteUrl: "https://github.com/example/repo.git", |
| 19 | }, |
| 20 | }; |
| 21 | |
| 22 | const otherIdentity = { |
| 23 | canonicalKey: "github.com/example/other", |
| 24 | locator: { |
| 25 | source: "git-remote" as const, |
| 26 | remoteName: "origin", |
| 27 | remoteUrl: "https://github.com/example/other.git", |
| 28 | }, |
| 29 | }; |
| 30 | |
| 31 | describe("applyShellStreamEvent", () => { |
| 32 | it("ignores stale project updates without mutating the snapshot", () => { |
| 33 | const snapshotWithProject = { |
| 34 | ...v2ShellSnapshot, |
| 35 | snapshotSequence: 4, |
| 36 | projects: [v2Project], |
| 37 | }; |
| 38 | |
| 39 | for (const sequence of [3, 4]) { |
| 40 | const next = applyShellStreamEvent(snapshotWithProject, { |
| 41 | kind: "project.updated", |
| 42 | sequence, |
| 43 | project: { ...v2Project, title: "Stale Title" }, |
| 44 | }); |
| 45 | |
| 46 | expect(next).toBe(snapshotWithProject); |
| 47 | expect(next.snapshotSequence).toBe(4); |
| 48 | expect(next.projects[0]?.title).toBe(v2Project.title); |
| 49 | } |
| 50 | }); |
| 51 | |
| 52 | it("keeps prior repositoryIdentity when a delta arrives with null identity", () => { |
| 53 | const withIdentity = applyShellStreamEvent(v2ShellSnapshot, { |
| 54 | kind: "project.updated", |
| 55 | sequence: 1, |
| 56 | project: { ...v2Project, repositoryIdentity }, |
| 57 | }); |
| 58 | expect(withIdentity.projects[0]?.repositoryIdentity).toEqual(repositoryIdentity); |
| 59 | |
| 60 | const withoutIdentity = applyShellStreamEvent(withIdentity, { |
| 61 | kind: "project.updated", |
| 62 | sequence: 2, |
| 63 | project: { ...v2Project, title: "Still same root", repositoryIdentity: null }, |
| 64 | }); |
| 65 | expect(withoutIdentity.projects[0]?.title).toBe("Still same root"); |
| 66 | expect(withoutIdentity.projects[0]?.repositoryIdentity).toEqual(repositoryIdentity); |
| 67 | }); |
| 68 | |
| 69 | it("does not keep prior repositoryIdentity after a workspace root move", () => { |
| 70 | const withIdentity = applyShellStreamEvent(v2ShellSnapshot, { |
| 71 | kind: "project.updated", |
| 72 | sequence: 1, |
| 73 | project: { ...v2Project, repositoryIdentity }, |
| 74 | }); |
| 75 | |
| 76 | const moved = applyShellStreamEvent(withIdentity, { |
| 77 | kind: "project.updated", |
| 78 | sequence: 2, |
| 79 | project: { |
| 80 | ...v2Project, |
| 81 | workspaceRoot: "/tmp/other-root", |
| 82 | repositoryIdentity: null, |
| 83 | }, |
| 84 | }); |
| 85 | expect(moved.projects[0]?.workspaceRoot).toBe("/tmp/other-root"); |
| 86 | expect(moved.projects[0]?.repositoryIdentity).toBeNull(); |
| 87 | }); |
| 88 | |
| 89 | it("authoritative lower-sequence reset replaces client-ahead structural state", () => { |
| 90 | const unchanged = { ...v2Project, id: ProjectId.make("project-unchanged"), repositoryIdentity }; |
| 91 | const previous = { |
| 92 | ...v2ShellSnapshot, |
| 93 | snapshotSequence: 9, |
| 94 | projects: [{ ...v2Project, title: "Client ahead", repositoryIdentity }, unchanged], |
| 95 | threads: [{ ...v2ThreadShell, title: "Local-only thread" }], |
| 96 | }; |
| 97 | const next = mergeShellSnapshotProjects(previous, { |
| 98 | ...v2ShellSnapshot, |
| 99 | snapshotSequence: 3, |
| 100 | projects: [ |
| 101 | { ...v2Project, title: "Server reset", repositoryIdentity: null }, |
| 102 | { ...unchanged, scripts: [...unchanged.scripts] }, |
| 103 | ], |
| 104 | threads: [{ ...v2ThreadShell, title: "Server thread" }], |
| 105 | }); |
| 106 | |
| 107 | expect(next.snapshotSequence).toBe(3); |
| 108 | expect(next.projects[0]?.title).toBe("Server reset"); |
| 109 | expect(next.projects[0]?.repositoryIdentity).toEqual(repositoryIdentity); |
| 110 | expect(next.projects[1]).toBe(unchanged); |
| 111 | expect( |
| 112 | mergeShellSnapshotProjects(next, { ...v2ShellSnapshot, projects: [...next.projects] }) |
| 113 | .projects, |
| 114 | ).toBe(next.projects); |
| 115 | expect(next.threads[0]?.title).toBe("Server thread"); |
| 116 | }); |
| 117 | |
| 118 | it("client-ahead survives lower marked enrichment then still resets on unmarked authoritative", () => { |
| 119 | const previous = { |
| 120 | ...v2ShellSnapshot, |
| 121 | snapshotSequence: 20, |
| 122 | projects: [{ ...v2Project, title: "Client ahead", repositoryIdentity }], |
| 123 | threads: [{ ...v2ThreadShell, title: "Local-only thread" }], |
| 124 | }; |
| 125 | const serverSnapshot = { |
| 126 | ...v2ShellSnapshot, |
| 127 | snapshotSequence: 3, |
| 128 | projects: [{ ...v2Project, title: "Server reset", repositoryIdentity: null }], |
| 129 | threads: [{ ...v2ThreadShell, title: "Server thread" }], |
| 130 | }; |
| 131 | |
| 132 | const afterEnrichment = mergeShellSnapshotProjects(previous, serverSnapshot, { |
| 133 | resolvedRepositoryIdentityRoots: [v2Project.workspaceRoot], |
| 134 | }); |
| 135 | expect(afterEnrichment.snapshotSequence).toBe(20); |
| 136 | expect(afterEnrichment.projects[0]?.title).toBe("Client ahead"); |
| 137 | expect(afterEnrichment.projects[0]?.repositoryIdentity).toBeNull(); |
| 138 | expect(afterEnrichment.threads[0]?.title).toBe("Local-only thread"); |
| 139 | |
| 140 | const afterAuthoritative = mergeShellSnapshotProjects(afterEnrichment, serverSnapshot); |
| 141 | expect(afterAuthoritative.snapshotSequence).toBe(3); |
| 142 | expect(afterAuthoritative.projects[0]?.title).toBe("Server reset"); |
| 143 | expect(afterAuthoritative.projects[0]?.repositoryIdentity).toBeNull(); |
| 144 | expect(afterAuthoritative.threads[0]?.title).toBe("Server thread"); |
| 145 | }); |
| 146 | |
| 147 | it("takes identity from a lower-sequence enrichment without reverting live thread state", () => { |
| 148 | const previous = { |
| 149 | ...v2ShellSnapshot, |
| 150 | snapshotSequence: 5, |
| 151 | projects: [{ ...v2Project, repositoryIdentity: null }], |
| 152 | threads: [{ ...v2ThreadShell, title: "Newest title" }], |
| 153 | }; |
| 154 | const next = mergeShellSnapshotProjects( |
| 155 | previous, |
| 156 | { |
| 157 | ...v2ShellSnapshot, |
| 158 | snapshotSequence: 4, |
| 159 | projects: [{ ...v2Project, repositoryIdentity }], |
| 160 | threads: [{ ...v2ThreadShell, title: "Stale title" }], |
| 161 | }, |
| 162 | { resolvedRepositoryIdentityRoots: [v2Project.workspaceRoot] }, |
| 163 | ); |
| 164 | |
| 165 | expect(next.snapshotSequence).toBe(5); |
| 166 | expect(next.threads[0]?.title).toBe("Newest title"); |
| 167 | expect(next.projects[0]?.repositoryIdentity).toEqual(repositoryIdentity); |
| 168 | }); |
| 169 | |
| 170 | it("lower-sequence enrichment cannot resurrect empty structural state", () => { |
| 171 | const previous = { |
| 172 | ...v2ShellSnapshot, |
| 173 | snapshotSequence: 7, |
| 174 | projects: [], |
| 175 | threads: [], |
| 176 | archivedThreads: [], |
| 177 | }; |
| 178 | const next = mergeShellSnapshotProjects( |
| 179 | previous, |
| 180 | { |
| 181 | ...v2ShellSnapshot, |
| 182 | snapshotSequence: 4, |
| 183 | projects: [{ ...v2Project, repositoryIdentity }], |
| 184 | threads: [v2ThreadShell], |
| 185 | }, |
| 186 | { resolvedRepositoryIdentityRoots: [v2Project.workspaceRoot] }, |
| 187 | ); |
| 188 | |
| 189 | expect(next.snapshotSequence).toBe(7); |
| 190 | expect(next.projects).toEqual([]); |
| 191 | expect(next.threads).toEqual([]); |
| 192 | }); |
| 193 | |
| 194 | it("resolved null clears identity only for the marked root", () => { |
| 195 | const otherProject = { |
| 196 | ...v2Project, |
| 197 | id: ProjectId.make("project-other"), |
| 198 | workspaceRoot: "/workspace/other", |
| 199 | repositoryIdentity: otherIdentity, |
| 200 | }; |
| 201 | const previous = { |
| 202 | ...v2ShellSnapshot, |
| 203 | snapshotSequence: 5, |
| 204 | projects: [{ ...v2Project, repositoryIdentity }, otherProject], |
| 205 | }; |
| 206 | const next = mergeShellSnapshotProjects( |
| 207 | previous, |
| 208 | { |
| 209 | ...v2ShellSnapshot, |
| 210 | snapshotSequence: 4, |
| 211 | projects: [ |
| 212 | { ...v2Project, repositoryIdentity: null }, |
| 213 | { ...otherProject, repositoryIdentity: null }, |
| 214 | ], |
| 215 | }, |
| 216 | { resolvedRepositoryIdentityRoots: [v2Project.workspaceRoot] }, |
| 217 | ); |
| 218 | |
| 219 | expect(next.snapshotSequence).toBe(5); |
| 220 | expect(next.projects).toHaveLength(2); |
| 221 | expect(next.projects[0]?.repositoryIdentity).toBeNull(); |
| 222 | expect(next.projects[1]?.repositoryIdentity).toEqual(otherIdentity); |
| 223 | }); |
| 224 | |
| 225 | it("does not replace a live identity with one from an unmarked lower-sequence enrichment", () => { |
| 226 | const liveIdentity = { |
| 227 | canonicalKey: "github.com/example/live", |
| 228 | locator: { |
| 229 | source: "git-remote" as const, |
| 230 | remoteName: "origin", |
| 231 | remoteUrl: "https://github.com/example/live.git", |
| 232 | }, |
| 233 | }; |
| 234 | const staleIdentity = { |
| 235 | canonicalKey: "github.com/example/stale", |
| 236 | locator: { |
| 237 | source: "git-remote" as const, |
| 238 | remoteName: "origin", |
| 239 | remoteUrl: "https://github.com/example/stale.git", |
| 240 | }, |
| 241 | }; |
| 242 | const next = mergeShellSnapshotProjects( |
| 243 | { |
| 244 | ...v2ShellSnapshot, |
| 245 | snapshotSequence: 5, |
| 246 | projects: [{ ...v2Project, repositoryIdentity: liveIdentity }], |
| 247 | }, |
| 248 | { |
| 249 | ...v2ShellSnapshot, |
| 250 | snapshotSequence: 4, |
| 251 | projects: [{ ...v2Project, repositoryIdentity: staleIdentity }], |
| 252 | }, |
| 253 | { resolvedRepositoryIdentityRoots: [] }, |
| 254 | ); |
| 255 | |
| 256 | expect(next.snapshotSequence).toBe(5); |
| 257 | expect(next.projects[0]?.repositoryIdentity).toEqual(liveIdentity); |
| 258 | }); |
| 259 | |
| 260 | it("keeps archive deltas out of the normal shell cache", () => { |
| 261 | const archived = applyShellStreamEvent(v2ShellSnapshot, { |
| 262 | kind: "thread.updated", |
| 263 | sequence: 3, |
| 264 | location: "archive", |
| 265 | thread: { ...v2ThreadShell, archivedAt: v2ThreadShell.updatedAt }, |
| 266 | }); |
| 267 | expect(archived.threads).toEqual([]); |
| 268 | expect(archived.archivedThreads).toEqual([]); |
| 269 | |
| 270 | const active = applyShellStreamEvent(archived, { |
| 271 | kind: "thread.updated", |
| 272 | sequence: 4, |
| 273 | location: "active", |
| 274 | thread: v2ThreadShell, |
| 275 | }); |
| 276 | expect(active.threads).toHaveLength(1); |
| 277 | expect(active.archivedThreads).toEqual([]); |
| 278 | }); |
| 279 | |
| 280 | it("leaves unknown future events unchanged", () => { |
| 281 | const next = applyShellStreamEvent(v2ShellSnapshot, { |
| 282 | kind: "future.event", |
| 283 | sequence: 99, |
| 284 | } as never); |
| 285 | |
| 286 | expect(next).toBe(v2ShellSnapshot); |
| 287 | }); |
| 288 | }); |
| 289 | |
| 290 | describe("reuseUnchangedThreadShells", () => { |
| 291 | const link: ThreadPullRequestLink = { |
| 292 | host: "github.com", |
| 293 | repository: "pingdotgg/t3code", |
| 294 | number: 3, |
| 295 | url: "https://github.com/pingdotgg/t3code/pull/3", |
| 296 | source: "agent", |
| 297 | linkedAt: "2026-06-20T00:00:00.000Z", |
| 298 | snapshot: null, |
| 299 | stack: null, |
| 300 | }; |
| 301 | const linked = { ...v2ThreadShell, pullRequests: [link] }; |
| 302 | const other = { ...v2ThreadShell, id: ThreadId.make("thread-other"), title: "Other" }; |
| 303 | |
| 304 | it("keeps the previous object for an unchanged row, even without its deferred links", () => { |
| 305 | const previous = { ...v2ShellSnapshot, threads: [linked, other] }; |
| 306 | const { pullRequests: _links, ...withoutLinks } = linked; |
| 307 | const next = reuseUnchangedThreadShells(previous, { |
| 308 | ...v2ShellSnapshot, |
| 309 | snapshotSequence: 5, |
| 310 | threads: [withoutLinks, { ...other, title: "Renamed" }], |
| 311 | }); |
| 312 | expect(next.snapshotSequence).toBe(5); |
| 313 | expect(next.threads[0]).toBe(linked); |
| 314 | expect(next.threads[1]).not.toBe(other); |
| 315 | expect(next.threads[1]?.title).toBe("Renamed"); |
| 316 | }); |
| 317 | |
| 318 | it("retains deferred links when the only row changes status", () => { |
| 319 | const { pullRequests: _links, ...withoutLinks } = linked; |
| 320 | const next = reuseUnchangedThreadShells( |
| 321 | { ...v2ShellSnapshot, threads: [linked] }, |
| 322 | { |
| 323 | ...v2ShellSnapshot, |
| 324 | snapshotSequence: 5, |
| 325 | threads: [{ ...withoutLinks, status: "running" }], |
| 326 | }, |
| 327 | ); |
| 328 | expect(next.snapshotSequence).toBe(5); |
| 329 | expect(next.threads[0]?.status).toBe("running"); |
| 330 | expect(next.threads[0]?.pullRequests).toBe(linked.pullRequests); |
| 331 | }); |
| 332 | |
| 333 | it("keeps an explicit link removal when metadata also changes", () => { |
| 334 | const updated = { ...linked, title: "Renamed", pullRequests: [] }; |
| 335 | const incoming = { ...v2ShellSnapshot, threads: [updated] }; |
| 336 | const next = reuseUnchangedThreadShells({ ...v2ShellSnapshot, threads: [linked] }, incoming); |
| 337 | expect(next).toBe(incoming); |
| 338 | expect(next.threads[0]?.pullRequests).toEqual([]); |
| 339 | }); |
| 340 | }); |
| 341 | |
| 342 | describe("applyShellStreamEvents", () => { |
| 343 | const row = (id: string) => ({ ...v2ThreadShell, id: ThreadId.make(id) }); |
| 344 | const a = row("a"); |
| 345 | const b = row("b"); |
| 346 | const unchanged = row("unchanged"); |
| 347 | const archived = row("archived"); |
| 348 | const oldArchive = row("old-archive"); |
| 349 | const added = row("new"); |
| 350 | const update = ( |
| 351 | sequence: number, |
| 352 | thread: typeof v2ThreadShell, |
| 353 | location: "active" | "archive" = "active", |
| 354 | ): ShellStreamEvent => ({ kind: "thread.updated", sequence, location, thread }); |
| 355 | const remove = (sequence: number, thread: typeof v2ThreadShell): ShellStreamEvent => ({ |
| 356 | kind: "thread.removed", |
| 357 | sequence, |
| 358 | location: "active", |
| 359 | threadId: thread.id, |
| 360 | }); |
| 361 | |
| 362 | it("matches sequential mixed deltas, including remove/reinsert order and stale events", () => { |
| 363 | const otherProject = { ...v2Project, id: ProjectId.make("other-project") }; |
| 364 | const seed = { |
| 365 | ...v2ShellSnapshot, |
| 366 | snapshotSequence: 4, |
| 367 | projects: [{ ...v2Project, repositoryIdentity }, otherProject], |
| 368 | threads: [a, b, unchanged], |
| 369 | archivedThreads: [archived, oldArchive], |
| 370 | }; |
| 371 | const events: Array<ShellStreamEvent> = [ |
| 372 | update(5, { ...b, title: "Renamed" }), |
| 373 | remove(5, a), |
| 374 | remove(6, a), |
| 375 | update(7, a), |
| 376 | update(8, b, "archive"), |
| 377 | update(9, archived), |
| 378 | update(10, oldArchive, "archive"), |
| 379 | update(11, added), |
| 380 | remove(12, { ...a, id: ThreadId.make("missing") }), |
| 381 | remove(11, added), |
| 382 | remove(13, added), |
| 383 | update(14, added), |
| 384 | update(15, { ...archived }), |
| 385 | { kind: "project.updated", sequence: 16, project: { ...v2Project, title: "Updated" } }, |
| 386 | { kind: "project.updated", sequence: 17, project: { ...v2Project, workspaceRoot: "/moved" } }, |
| 387 | { kind: "project.removed", sequence: 18, projectId: v2Project.id }, |
| 388 | { kind: "project.updated", sequence: 19, project: v2Project }, |
| 389 | ]; |
| 390 | const sequential = events.reduce(applyShellStreamEvent, seed); |
| 391 | const next = applyShellStreamEvents(seed, events); |
| 392 | expect(next).toEqual(sequential); |
| 393 | expect(next.threads.map((row) => row.id)).toEqual([unchanged.id, a.id, archived.id, added.id]); |
| 394 | expect(next.threads[0]).toBe(unchanged); |
| 395 | expect(next.threads[2]).toBe(archived); |
| 396 | expect(next.projects[0]).toBe(otherProject); |
| 397 | expect(next.archivedThreads).toEqual([]); |
| 398 | expect(seed.threads).toEqual([a, b, unchanged]); |
| 399 | expect(seed.archivedThreads).toEqual([archived, oldArchive]); |
| 400 | // Identity retention must use the latest project in this batch. |
| 401 | expect(applyShellStreamEvents(seed, events.slice(0, 14)).projects[0]?.repositoryIdentity).toBe( |
| 402 | repositoryIdentity, |
| 403 | ); |
| 404 | expect( |
| 405 | applyShellStreamEvents(seed, events.slice(0, 15)).projects[0]?.repositoryIdentity, |
| 406 | ).toBeNull(); |
| 407 | }); |
| 408 | |
| 409 | it("keeps collection identities for equal rows and rejects stale deltas without indexing", () => { |
| 410 | const seed = { ...v2ShellSnapshot, threads: [a, b], snapshotSequence: 4 }; |
| 411 | const next = applyShellStreamEvents(seed, [update(5, { ...a }), update(6, { ...b })]); |
| 412 | expect(next).toEqual( |
| 413 | [update(5, { ...a }), update(6, { ...b })].reduce(applyShellStreamEvent, seed), |
| 414 | ); |
| 415 | expect(next.threads).toBe(seed.threads); |
| 416 | expect(next.projects).toBe(seed.projects); |
| 417 | expect(next.archivedThreads).toBe(seed.archivedThreads); |
| 418 | expect(next.snapshotSequence).toBe(6); |
| 419 | expect(applyShellStreamEvents(seed, [remove(3, a), update(4, b)])).toBe(seed); |
| 420 | expect(applyShellStreamEvents(seed, [])).toBe(seed); |
| 421 | }); |
| 422 | |
| 423 | it("does not advance the cursor for an unknown future event", () => { |
| 424 | const events = [ |
| 425 | { kind: "future.event", sequence: 99 } as never, |
| 426 | update(1, { ...a, title: "Changed" }), |
| 427 | ]; |
| 428 | expect(applyShellStreamEvents(v2ShellSnapshot, events)).toEqual( |
| 429 | events.reduce(applyShellStreamEvent, v2ShellSnapshot), |
| 430 | ); |
| 431 | }); |
| 432 | }); |