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, 03:37 UTC
| 1 | import { describe, expect, it, vi } from "@effect/vitest"; |
| 2 | import * as NodeCrypto from "@effect/platform-node/NodeCrypto"; |
| 3 | import * as NodeServices from "@effect/platform-node/NodeServices"; |
| 4 | import { |
| 5 | CommandId, |
| 6 | EnvironmentId, |
| 7 | type OrchestrationV2ThreadProjection, |
| 8 | type Project, |
| 9 | ProjectId, |
| 10 | ProviderInstanceId, |
| 11 | ThreadId, |
| 12 | WorktreeMcpHandoffInput, |
| 13 | } from "@t3tools/contracts"; |
| 14 | import * as Cause from "effect/Cause"; |
| 15 | import * as Deferred from "effect/Deferred"; |
| 16 | import * as Effect from "effect/Effect"; |
| 17 | import * as Exit from "effect/Exit"; |
| 18 | import * as Fiber from "effect/Fiber"; |
| 19 | import * as FileSystem from "effect/FileSystem"; |
| 20 | import * as Layer from "effect/Layer"; |
| 21 | import * as Option from "effect/Option"; |
| 22 | import * as PlatformError from "effect/PlatformError"; |
| 23 | import * as Schema from "effect/Schema"; |
| 24 | |
| 25 | import * as GitWorkflowService from "../git/GitWorkflowService.ts"; |
| 26 | import * as GitVcsDriver from "../vcs/GitVcsDriver.ts"; |
| 27 | import * as ServerConfig from "../config.ts"; |
| 28 | import { |
| 29 | OrchestratorDispatchError, |
| 30 | OrchestratorProjectionError, |
| 31 | } from "../orchestration-v2/Orchestrator.ts"; |
| 32 | import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts"; |
| 33 | import * as ProjectService from "../project/ProjectService.ts"; |
| 34 | import * as ProjectSetupScriptRunner from "../project/ProjectSetupScriptRunner.ts"; |
| 35 | import * as ServerSettings from "../serverSettings.ts"; |
| 36 | import * as VcsStatusBroadcaster from "../vcs/VcsStatusBroadcaster.ts"; |
| 37 | import type * as McpInvocationContext from "./McpInvocationContext.ts"; |
| 38 | import * as WorktreeMcpService from "./WorktreeMcpService.ts"; |
| 39 | |
| 40 | const environmentId = EnvironmentId.make("environment-worktree-test"); |
| 41 | const threadId = ThreadId.make("thread-worktree-test"); |
| 42 | const projectId = ProjectId.make("project-worktree-test"); |
| 43 | const workspaceRoot = "/repo/project"; |
| 44 | |
| 45 | const makeScope = ( |
| 46 | capabilities: ReadonlySet<McpInvocationContext.McpCapability>, |
| 47 | ): McpInvocationContext.McpInvocationScope => ({ |
| 48 | environmentId, |
| 49 | requestNamespace: "provider-session-worktree-test", |
| 50 | thread: { |
| 51 | threadId, |
| 52 | providerSessionId: "provider-session-worktree-test", |
| 53 | providerInstanceId: ProviderInstanceId.make("claudeAgent"), |
| 54 | }, |
| 55 | client: undefined, |
| 56 | capabilities, |
| 57 | issuedAt: 1, |
| 58 | }); |
| 59 | |
| 60 | interface ThreadFixture { |
| 61 | readonly branch?: string | null; |
| 62 | readonly worktreePath?: string | null; |
| 63 | readonly archivedAt?: string | null; |
| 64 | readonly deletedAt?: string | null; |
| 65 | } |
| 66 | |
| 67 | const makeProjection = (overrides: ThreadFixture = {}): OrchestrationV2ThreadProjection => |
| 68 | ({ |
| 69 | thread: { |
| 70 | id: threadId, |
| 71 | projectId, |
| 72 | title: "Worktree test thread", |
| 73 | branch: null, |
| 74 | worktreePath: null, |
| 75 | archivedAt: null, |
| 76 | deletedAt: null, |
| 77 | ...overrides, |
| 78 | }, |
| 79 | }) as OrchestrationV2ThreadProjection; |
| 80 | |
| 81 | const project: Project = { |
| 82 | id: projectId, |
| 83 | title: "Worktree test project", |
| 84 | workspaceRoot, |
| 85 | defaultModelSelection: null, |
| 86 | scripts: [], |
| 87 | createdAt: "2026-01-01T00:00:00.000Z", |
| 88 | updatedAt: "2026-01-01T00:00:00.000Z", |
| 89 | deletedAt: null, |
| 90 | } as Project; |
| 91 | |
| 92 | interface HarnessOptions { |
| 93 | readonly git?: Partial<GitWorkflowService.GitWorkflowService["Service"]>; |
| 94 | readonly thread?: ThreadFixture | null; |
| 95 | readonly threadReadError?: "projection" | "dispatch"; |
| 96 | readonly capabilities?: ReadonlySet<McpInvocationContext.McpCapability>; |
| 97 | readonly currentBranch?: string | null; |
| 98 | readonly notARepo?: boolean; |
| 99 | readonly newWorktreesStartFromOrigin?: boolean; |
| 100 | readonly projectNewWorktreesStartFromOrigin?: boolean; |
| 101 | readonly setupScript?: "started" | "no-script" | "fails" | "dies"; |
| 102 | readonly dispatchFails?: boolean; |
| 103 | readonly dispatchDies?: boolean; |
| 104 | readonly dispatchInterrupts?: boolean; |
| 105 | readonly dispatchGate?: Effect.Effect<void>; |
| 106 | readonly threadAttachedOnRecheck?: boolean; |
| 107 | readonly threadArchivedOnRecheck?: boolean; |
| 108 | readonly threadReadFailsOnRecheck?: boolean; |
| 109 | readonly projectMissing?: boolean; |
| 110 | readonly projectReadFails?: boolean; |
| 111 | readonly existingBranchWorktreePath?: string | null; |
| 112 | readonly createWorktreeFails?: boolean; |
| 113 | readonly fetchWorktreeBaseFails?: boolean; |
| 114 | readonly worktreeBaseMissing?: boolean; |
| 115 | readonly removeWorktreeFails?: boolean; |
| 116 | readonly deleteLocalBranchFails?: boolean; |
| 117 | readonly createWorktreeGate?: Effect.Effect<void>; |
| 118 | readonly existsFails?: boolean; |
| 119 | } |
| 120 | |
| 121 | const makeHarness = (options: HarnessOptions = {}) => { |
| 122 | const thread = options.thread === undefined ? {} : options.thread; |
| 123 | const scope = makeScope(options.capabilities ?? new Set(["preview", "worktree"])); |
| 124 | const dispatch = vi.fn((_: unknown) => |
| 125 | (options.dispatchGate ?? Effect.void).pipe( |
| 126 | Effect.andThen( |
| 127 | options.dispatchInterrupts |
| 128 | ? (Effect.failCause(Cause.interrupt()) as never) |
| 129 | : options.dispatchDies |
| 130 | ? Effect.die(new Error("dispatch defect")) |
| 131 | : options.dispatchFails |
| 132 | ? (Effect.fail("simulated dispatch failure") as never) |
| 133 | : Effect.succeed({ sequence: 1, storedEvents: [] }), |
| 134 | ), |
| 135 | ), |
| 136 | ); |
| 137 | const listLocalBranchNames = vi.fn((_: string) => |
| 138 | Effect.succeed( |
| 139 | options.existingBranchWorktreePath === undefined |
| 140 | ? ["dev"] |
| 141 | : ["dev", "feature/taken", "feature/taken-idle"], |
| 142 | ), |
| 143 | ); |
| 144 | const getThreadRecords = vi.fn((id: ThreadId) => { |
| 145 | if (options.threadReadError === "dispatch") { |
| 146 | return Effect.fail( |
| 147 | new OrchestratorDispatchError({ |
| 148 | commandId: CommandId.make("command:test:read"), |
| 149 | commandType: "thread.metadata.update", |
| 150 | }), |
| 151 | ) as never; |
| 152 | } |
| 153 | if (options.threadReadFailsOnRecheck === true && getThreadRecords.mock.calls.length > 1) { |
| 154 | return Effect.fail( |
| 155 | new OrchestratorDispatchError({ |
| 156 | commandId: CommandId.make("command:test:recheck"), |
| 157 | commandType: "thread.metadata.update", |
| 158 | }), |
| 159 | ) as never; |
| 160 | } |
| 161 | if ( |
| 162 | options.threadAttachedOnRecheck === true && |
| 163 | getThreadRecords.mock.calls.length > 1 && |
| 164 | thread !== null |
| 165 | ) { |
| 166 | return Effect.succeed( |
| 167 | makeProjection({ ...thread, worktreePath: "/worktrees/project/raced" }), |
| 168 | ); |
| 169 | } |
| 170 | if ( |
| 171 | options.threadArchivedOnRecheck === true && |
| 172 | getThreadRecords.mock.calls.length > 1 && |
| 173 | thread !== null |
| 174 | ) { |
| 175 | return Effect.succeed(makeProjection({ ...thread, archivedAt: "2026-01-02T00:00:00.000Z" })); |
| 176 | } |
| 177 | return id === threadId && thread !== null |
| 178 | ? Effect.succeed(makeProjection(thread)) |
| 179 | : Effect.fail(new OrchestratorProjectionError({ threadId: id })); |
| 180 | }); |
| 181 | const getById = vi.fn((id: ProjectId) => |
| 182 | options.projectReadFails |
| 183 | ? (Effect.fail("simulated project read failure") as never) |
| 184 | : Effect.succeed( |
| 185 | id === projectId && options.projectMissing !== true |
| 186 | ? Option.some(project) |
| 187 | : Option.none(), |
| 188 | ), |
| 189 | ); |
| 190 | const removeWorktree = vi.fn((_: unknown) => |
| 191 | options.removeWorktreeFails |
| 192 | ? (Effect.fail("simulated worktree removal failure") as never) |
| 193 | : Effect.void, |
| 194 | ); |
| 195 | const deleteLocalBranch = vi.fn((_: unknown) => |
| 196 | options.deleteLocalBranchFails |
| 197 | ? (Effect.fail("simulated local branch deletion failure") as never) |
| 198 | : Effect.void, |
| 199 | ); |
| 200 | const fetchWorktreeBaseCommit = vi.fn((_: unknown) => |
| 201 | options.fetchWorktreeBaseFails |
| 202 | ? (Effect.fail("simulated fetch failure") as never) |
| 203 | : options.worktreeBaseMissing |
| 204 | ? Effect.succeed(null) |
| 205 | : Effect.succeed({ commitSha: "abc123", remoteRefName: "origin/dev" }), |
| 206 | ); |
| 207 | const createWorktree = vi.fn( |
| 208 | (input: { readonly newRefName?: string | undefined; readonly path: string | null }) => |
| 209 | options.createWorktreeFails |
| 210 | ? (Effect.fail("simulated worktree creation failure") as never) |
| 211 | : (options.createWorktreeGate ?? Effect.void).pipe( |
| 212 | Effect.andThen( |
| 213 | Effect.succeed({ |
| 214 | worktree: { |
| 215 | path: input.path ?? `/worktrees/project/${input.newRefName}`, |
| 216 | refName: input.newRefName ?? "detached", |
| 217 | }, |
| 218 | }), |
| 219 | ), |
| 220 | ), |
| 221 | ); |
| 222 | const listRefs = vi.fn((input: { readonly cwd: string; readonly query?: string | undefined }) => |
| 223 | Effect.succeed({ |
| 224 | refs: |
| 225 | options.existingBranchWorktreePath === undefined |
| 226 | ? [] |
| 227 | : [ |
| 228 | { |
| 229 | name: input.query ?? "", |
| 230 | current: false, |
| 231 | isDefault: false, |
| 232 | worktreePath: options.existingBranchWorktreePath, |
| 233 | }, |
| 234 | ], |
| 235 | isRepo: true, |
| 236 | hasPrimaryRemote: true, |
| 237 | nextCursor: null, |
| 238 | totalCount: options.existingBranchWorktreePath === undefined ? 0 : 1, |
| 239 | }), |
| 240 | ); |
| 241 | const localStatus = vi.fn((_: unknown) => |
| 242 | Effect.succeed({ |
| 243 | isRepo: options.notARepo !== true, |
| 244 | hasPrimaryRemote: true, |
| 245 | isDefaultRef: false, |
| 246 | refName: options.currentBranch === undefined ? "dev" : options.currentBranch, |
| 247 | hasWorkingTreeChanges: false, |
| 248 | workingTree: { files: [], insertions: 0, deletions: 0 }, |
| 249 | }), |
| 250 | ); |
| 251 | const refreshStatus = vi.fn((_: string) => Effect.die("refreshStatus stub")); |
| 252 | const runForThread = vi.fn((input: { readonly worktreePath: string }) => { |
| 253 | switch (options.setupScript ?? "started") { |
| 254 | case "no-script": |
| 255 | return Effect.succeed({ status: "no-script" } as const); |
| 256 | case "dies": |
| 257 | return Effect.die(new Error("setup runner defect")); |
| 258 | case "fails": |
| 259 | return Effect.fail( |
| 260 | new ProjectSetupScriptRunner.ProjectSetupScriptProjectNotFoundError({ |
| 261 | threadId, |
| 262 | worktreePath: input.worktreePath, |
| 263 | }), |
| 264 | ); |
| 265 | default: |
| 266 | return Effect.succeed({ |
| 267 | status: "started", |
| 268 | async: false, |
| 269 | scriptId: "setup", |
| 270 | scriptName: "Setup", |
| 271 | scriptCommand: "vp install", |
| 272 | terminalId: "setup-terminal", |
| 273 | cwd: input.worktreePath, |
| 274 | } as const); |
| 275 | } |
| 276 | }); |
| 277 | |
| 278 | const layer = WorktreeMcpService.layer.pipe( |
| 279 | Layer.provide( |
| 280 | Layer.mergeAll( |
| 281 | Layer.mock(ThreadManagementService.ThreadManagementService)({ |
| 282 | dispatch, |
| 283 | getThreadRecords, |
| 284 | } satisfies Partial<ThreadManagementService.ThreadManagementService["Service"]>), |
| 285 | Layer.mock(ProjectService.ProjectService)({ |
| 286 | getById, |
| 287 | } satisfies Partial<ProjectService.ProjectService["Service"]>), |
| 288 | ServerSettings.layerTest({ |
| 289 | newWorktreesStartFromOrigin: options.newWorktreesStartFromOrigin ?? false, |
| 290 | ...(options.projectNewWorktreesStartFromOrigin === undefined |
| 291 | ? {} |
| 292 | : { |
| 293 | projectSettingsOverrides: { |
| 294 | [projectId]: { |
| 295 | newWorktreesStartFromOrigin: options.projectNewWorktreesStartFromOrigin, |
| 296 | }, |
| 297 | }, |
| 298 | }), |
| 299 | }), |
| 300 | Layer.mock(GitWorkflowService.GitWorkflowService)({ |
| 301 | listRefs, |
| 302 | listLocalBranchNames, |
| 303 | localStatus, |
| 304 | fetchWorktreeBaseCommit, |
| 305 | createWorktree, |
| 306 | removeWorktree, |
| 307 | deleteLocalBranch, |
| 308 | ...options.git, |
| 309 | } satisfies Partial<GitWorkflowService.GitWorkflowService["Service"]>), |
| 310 | Layer.mock(ProjectSetupScriptRunner.ProjectSetupScriptRunner)({ |
| 311 | runForThread, |
| 312 | } satisfies Partial<ProjectSetupScriptRunner.ProjectSetupScriptRunner["Service"]>), |
| 313 | Layer.mock(VcsStatusBroadcaster.VcsStatusBroadcaster)({ |
| 314 | refreshStatus, |
| 315 | } satisfies Partial<VcsStatusBroadcaster.VcsStatusBroadcaster["Service"]>), |
| 316 | NodeServices.layer, |
| 317 | NodeCrypto.layer, |
| 318 | options.existsFails |
| 319 | ? FileSystem.layerNoop({ |
| 320 | exists: (path) => |
| 321 | Effect.fail( |
| 322 | PlatformError.systemError({ |
| 323 | _tag: "PermissionDenied", |
| 324 | module: "FileSystem", |
| 325 | method: "exists", |
| 326 | pathOrDescriptor: path, |
| 327 | }), |
| 328 | ), |
| 329 | }) |
| 330 | : Layer.empty, |
| 331 | ), |
| 332 | ), |
| 333 | ); |
| 334 | |
| 335 | return { |
| 336 | layer, |
| 337 | scope, |
| 338 | listRefs, |
| 339 | dispatch, |
| 340 | fetchWorktreeBaseCommit, |
| 341 | createWorktree, |
| 342 | removeWorktree, |
| 343 | deleteLocalBranch, |
| 344 | localStatus, |
| 345 | runForThread, |
| 346 | }; |
| 347 | }; |
| 348 | |
| 349 | const expectTypedFailure = (exit: Exit.Exit<unknown, unknown>, expected: object): void => { |
| 350 | if (!Exit.isFailure(exit)) { |
| 351 | expect.fail(`Expected a failure exit, got: ${JSON.stringify(exit)}`); |
| 352 | } |
| 353 | const reason = exit.cause.reasons[0]; |
| 354 | if (reason?._tag !== "Fail") { |
| 355 | expect.fail(`Expected a typed Fail cause, got: ${reason?._tag ?? "no reason"}`); |
| 356 | } |
| 357 | expect(reason.error).toMatchObject(expected); |
| 358 | }; |
| 359 | |
| 360 | // Resolve once so calls share the in-flight guard. |
| 361 | const resolveService = (harness: ReturnType<typeof makeHarness>) => |
| 362 | WorktreeMcpService.WorktreeMcpService.pipe(Effect.provide(harness.layer)); |
| 363 | |
| 364 | const runHandoff = ( |
| 365 | harness: ReturnType<typeof makeHarness>, |
| 366 | input: Parameters<WorktreeMcpService.WorktreeMcpService["Service"]["handoff"]>[1], |
| 367 | ) => |
| 368 | Effect.gen(function* () { |
| 369 | const service = yield* WorktreeMcpService.WorktreeMcpService; |
| 370 | return yield* service.handoff(harness.scope, input); |
| 371 | }).pipe(Effect.provide(harness.layer)); |
| 372 | |
| 373 | const runStatus = (harness: ReturnType<typeof makeHarness>) => |
| 374 | Effect.gen(function* () { |
| 375 | const service = yield* WorktreeMcpService.WorktreeMcpService; |
| 376 | return yield* service.status(harness.scope); |
| 377 | }).pipe(Effect.provide(harness.layer)); |
| 378 | |
| 379 | const decodeHandoffInput = Schema.decodeUnknownEffect(WorktreeMcpHandoffInput); |
| 380 | |
| 381 | describe("t3_worktree_handoff", () => { |
| 382 | // regression: #22971 a separate send let the detach settle the run before its follow-up existed |
| 383 | it.effect("commits the continuation with the thread binding", () => { |
| 384 | const harness = makeHarness(); |
| 385 | return Effect.gen(function* () { |
| 386 | const result = yield* runHandoff(harness, { |
| 387 | branch: "feature/continue", |
| 388 | continuationPrompt: "Keep going.", |
| 389 | }); |
| 390 | expect(result.continuation).toEqual({ status: "scheduled", delivery: "queued" }); |
| 391 | expect(harness.dispatch).toHaveBeenCalledTimes(1); |
| 392 | expect(harness.dispatch).toHaveBeenCalledWith( |
| 393 | expect.objectContaining({ |
| 394 | type: "thread.metadata.update", |
| 395 | worktreePath: "/worktrees/project/feature/continue", |
| 396 | continuation: expect.objectContaining({ text: "Keep going." }), |
| 397 | }), |
| 398 | ); |
| 399 | }); |
| 400 | }); |
| 401 | |
| 402 | it.effect("uses the fetched commit and remote PR base for an explicit local alias", () => |
| 403 | Effect.gen(function* () { |
| 404 | const fs = yield* FileSystem.FileSystem; |
| 405 | const git = yield* GitVcsDriver.GitVcsDriver; |
| 406 | const directory = yield* fs.makeTempDirectoryScoped({ prefix: "handoff-remote-base-" }); |
| 407 | const cwd = `${directory}/repo`; |
| 408 | const remote = `${directory}/remote.git`; |
| 409 | const worktreePath = `${directory}/worktree`; |
| 410 | yield* fs.makeDirectory(cwd); |
| 411 | const command = (at: string, args: string[]) => |
| 412 | git.execute({ operation: "handoff-test", cwd: at, args }); |
| 413 | yield* command(cwd, ["init", "-b", "stable"]); |
| 414 | yield* command(cwd, ["config", "user.name", "Test"]); |
| 415 | yield* command(cwd, ["config", "user.email", "test@example.test"]); |
| 416 | yield* command(cwd, ["commit", "--allow-empty", "-m", "remote base"]); |
| 417 | const remoteHead = (yield* command(cwd, ["rev-parse", "HEAD"])).stdout.trim(); |
| 418 | yield* command(cwd, ["init", "--bare", remote]); |
| 419 | yield* command(cwd, ["remote", "add", "upstream", remote]); |
| 420 | yield* command(cwd, ["push", "-u", "upstream", "stable:release"]); |
| 421 | yield* command(cwd, ["commit", "--allow-empty", "-m", "local only"]); |
| 422 | const harness = makeHarness({ |
| 423 | git: { |
| 424 | fetchWorktreeBaseCommit: (input) => git.fetchWorktreeBaseCommit({ ...input, cwd }), |
| 425 | createWorktree: (input) => git.createWorktree({ ...input, cwd, path: worktreePath }), |
| 426 | }, |
| 427 | }); |
| 428 | const result = yield* runHandoff(harness, { |
| 429 | branch: "feature/from-remote", |
| 430 | baseRef: "stable", |
| 431 | startFromOrigin: true, |
| 432 | runSetupScript: false, |
| 433 | }); |
| 434 | |
| 435 | expect(result.worktreePath).toBe(worktreePath); |
| 436 | expect(result.startedFromOrigin).toBe(true); |
| 437 | expect(result.setupScript).toEqual({ status: "skipped" }); |
| 438 | expect((yield* command(worktreePath, ["rev-parse", "HEAD"])).stdout.trim()).toBe(remoteHead); |
| 439 | const preview = yield* git.getReviewDiffPreview({ cwd: worktreePath }); |
| 440 | const comparisonBase = preview.sources.find( |
| 441 | (source) => source.kind === "branch-range", |
| 442 | )!.baseRef; |
| 443 | expect( |
| 444 | (yield* command(worktreePath, ["rev-parse", `${comparisonBase}^{commit}`])).stdout.trim(), |
| 445 | ).toBe(remoteHead); |
| 446 | }).pipe( |
| 447 | Effect.provide( |
| 448 | GitVcsDriver.layer.pipe( |
| 449 | Layer.provide(ServerConfig.layerTest(process.cwd(), { prefix: "handoff-remote-git-" })), |
| 450 | Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)), |
| 451 | ), |
| 452 | ), |
| 453 | ), |
| 454 | ); |
| 455 | |
| 456 | it.effect("fails when the thread is already attached to a worktree", () => { |
| 457 | const harness = makeHarness({ |
| 458 | thread: { branch: "feature/existing", worktreePath: "/worktrees/project/existing" }, |
| 459 | }); |
| 460 | return Effect.gen(function* () { |
| 461 | const exit = yield* Effect.exit(runHandoff(harness, { branch: "feature/second" })); |
| 462 | expectTypedFailure(exit, { |
| 463 | _tag: "WorktreeMcpFailure", |
| 464 | code: "already_in_worktree", |
| 465 | }); |
| 466 | expect(harness.createWorktree).not.toHaveBeenCalled(); |
| 467 | }); |
| 468 | }); |
| 469 | |
| 470 | it.effect("rejects an existing branch with an actionable error naming its checkout", () => { |
| 471 | const harness = makeHarness({ existingBranchWorktreePath: "/elsewhere/checkout" }); |
| 472 | return Effect.gen(function* () { |
| 473 | const exit = yield* Effect.exit(runHandoff(harness, { branch: "feature/taken" })); |
| 474 | if (!Exit.isFailure(exit)) { |
| 475 | return expect.fail("expected a failure exit"); |
| 476 | } |
| 477 | const reason = exit.cause.reasons[0]; |
| 478 | expect(reason?._tag).toBe("Fail"); |
| 479 | const error = (reason as { readonly error: { code: string; message: string } }).error; |
| 480 | expect(error.code).toBe("invalid_request"); |
| 481 | expect(error.message).toContain("feature/taken"); |
| 482 | expect(error.message).toContain("already exists"); |
| 483 | expect(error.message).toContain("/elsewhere/checkout"); |
| 484 | expect(harness.createWorktree).not.toHaveBeenCalled(); |
| 485 | expect(harness.fetchWorktreeBaseCommit).not.toHaveBeenCalled(); |
| 486 | }); |
| 487 | }); |
| 488 | |
| 489 | it.effect("does not trip the pre-flight on similarly named branches", () => { |
| 490 | const harness = makeHarness({ existingBranchWorktreePath: null }); |
| 491 | return Effect.gen(function* () { |
| 492 | const result = yield* runHandoff(harness, { branch: "feature/take" }); |
| 493 | expect(result.branch).toBe("feature/take"); |
| 494 | expect(harness.createWorktree).toHaveBeenCalledTimes(1); |
| 495 | }); |
| 496 | }); |
| 497 | |
| 498 | it.effect("propagates an interrupted dispatch without rolling back the worktree", () => { |
| 499 | const harness = makeHarness({ dispatchInterrupts: true }); |
| 500 | return Effect.gen(function* () { |
| 501 | const exit = yield* Effect.exit(runHandoff(harness, { branch: "feature/dispatch-int" })); |
| 502 | if (!Exit.isFailure(exit)) { |
| 503 | return expect.fail("expected a failure exit"); |
| 504 | } |
| 505 | expect(Cause.hasInterruptsOnly(exit.cause)).toBe(true); |
| 506 | expect(harness.removeWorktree).not.toHaveBeenCalled(); |
| 507 | }); |
| 508 | }); |
| 509 | |
| 510 | it.effect("falls back to the local base when no remote holds it", () => { |
| 511 | const harness = makeHarness({ worktreeBaseMissing: true }); |
| 512 | return Effect.gen(function* () { |
| 513 | const result = yield* runHandoff(harness, { |
| 514 | branch: "feature/local-fallback", |
| 515 | baseRef: "dev", |
| 516 | startFromOrigin: true, |
| 517 | }); |
| 518 | expect(harness.createWorktree).toHaveBeenCalledWith( |
| 519 | expect.objectContaining({ refName: "dev", baseRefName: "dev" }), |
| 520 | ); |
| 521 | expect(result.startedFromOrigin).toBe(false); |
| 522 | }); |
| 523 | }); |
| 524 | |
| 525 | it.effect("defaults startFromOrigin to the project's override", () => { |
| 526 | const harness = makeHarness({ projectNewWorktreesStartFromOrigin: true }); |
| 527 | return Effect.gen(function* () { |
| 528 | const result = yield* runHandoff(harness, { branch: "feature/project-origin" }); |
| 529 | expect(harness.fetchWorktreeBaseCommit).toHaveBeenCalled(); |
| 530 | expect(result.startedFromOrigin).toBe(true); |
| 531 | }); |
| 532 | }); |
| 533 | |
| 534 | it.effect("removes the created worktree when the thread update dies with a defect", () => { |
| 535 | const harness = makeHarness({ dispatchDies: true }); |
| 536 | return Effect.gen(function* () { |
| 537 | const exit = yield* Effect.exit(runHandoff(harness, { branch: "feature/dispatch-defect" })); |
| 538 | expectTypedFailure(exit, { _tag: "WorktreeMcpFailure", code: "operation_failed" }); |
| 539 | expect(harness.removeWorktree).toHaveBeenCalledWith({ |
| 540 | cwd: workspaceRoot, |
| 541 | path: "/worktrees/project/feature/dispatch-defect", |
| 542 | force: true, |
| 543 | }); |
| 544 | }); |
| 545 | }); |
| 546 | |
| 547 | it.effect("re-checks attachment after creating the worktree and backs out on a race", () => { |
| 548 | const harness = makeHarness({ threadAttachedOnRecheck: true }); |
| 549 | return Effect.gen(function* () { |
| 550 | const exit = yield* Effect.exit(runHandoff(harness, { branch: "feature/raced" })); |
| 551 | expectTypedFailure(exit, { _tag: "WorktreeMcpFailure", code: "already_in_worktree" }); |
| 552 | expect(harness.createWorktree).toHaveBeenCalledTimes(1); |
| 553 | expect(harness.removeWorktree).toHaveBeenCalledWith({ |
| 554 | cwd: workspaceRoot, |
| 555 | path: "/worktrees/project/feature/raced", |
| 556 | force: true, |
| 557 | }); |
| 558 | expect(harness.deleteLocalBranch).toHaveBeenCalledWith({ |
| 559 | cwd: workspaceRoot, |
| 560 | refName: "feature/raced", |
| 561 | force: true, |
| 562 | }); |
| 563 | expect(harness.dispatch).not.toHaveBeenCalled(); |
| 564 | }); |
| 565 | }); |
| 566 | |
| 567 | it.effect("removes the created worktree when the recheck read fails", () => { |
| 568 | const harness = makeHarness({ threadReadFailsOnRecheck: true }); |
| 569 | return Effect.gen(function* () { |
| 570 | const exit = yield* Effect.exit(runHandoff(harness, { branch: "feature/recheck-fails" })); |
| 571 | expectTypedFailure(exit, { _tag: "WorktreeMcpFailure", code: "operation_failed" }); |
| 572 | expect(harness.removeWorktree).toHaveBeenCalledWith({ |
| 573 | cwd: workspaceRoot, |
| 574 | path: "/worktrees/project/feature/recheck-fails", |
| 575 | force: true, |
| 576 | }); |
| 577 | expect(harness.dispatch).not.toHaveBeenCalled(); |
| 578 | }); |
| 579 | }); |
| 580 | |
| 581 | it.effect("backs out when the thread is archived during worktree creation", () => { |
| 582 | const harness = makeHarness({ threadArchivedOnRecheck: true }); |
| 583 | return Effect.gen(function* () { |
| 584 | const exit = yield* Effect.exit(runHandoff(harness, { branch: "feature/archived-race" })); |
| 585 | expectTypedFailure(exit, { _tag: "WorktreeMcpFailure", code: "invalid_request" }); |
| 586 | expect(harness.dispatch).not.toHaveBeenCalled(); |
| 587 | expect(harness.removeWorktree).toHaveBeenCalledWith({ |
| 588 | cwd: workspaceRoot, |
| 589 | path: "/worktrees/project/feature/archived-race", |
| 590 | force: true, |
| 591 | }); |
| 592 | }); |
| 593 | }); |
| 594 | |
| 595 | it.effect("runs the setup script even when interrupted during the binding dispatch", () => |
| 596 | Effect.gen(function* () { |
| 597 | const gate = yield* Deferred.make<void>(); |
| 598 | const harness = makeHarness({ dispatchGate: Deferred.await(gate) }); |
| 599 | |
| 600 | const fiber = yield* Effect.forkChild( |
| 601 | runHandoff(harness, { |
| 602 | branch: "feature/interrupted", |
| 603 | continuationPrompt: "Keep going in the worktree.", |
| 604 | }), |
| 605 | ); |
| 606 | yield* Effect.yieldNow; |
| 607 | const interruption = yield* Effect.forkChild(Fiber.interrupt(fiber)); |
| 608 | yield* Effect.yieldNow; |
| 609 | yield* Deferred.succeed(gate, undefined); |
| 610 | yield* Fiber.await(fiber); |
| 611 | yield* Fiber.join(interruption); |
| 612 | |
| 613 | expect(harness.dispatch).toHaveBeenCalledTimes(1); |
| 614 | expect(harness.runForThread).toHaveBeenCalledTimes(1); |
| 615 | }), |
| 616 | ); |
| 617 | |
| 618 | it.effect("creates the worktree in the managed directory even when a call names a path", () => { |
| 619 | const harness = makeHarness(); |
| 620 | return Effect.gen(function* () { |
| 621 | const input = yield* decodeHandoffInput({ |
| 622 | branch: "feature/elsewhere", |
| 623 | path: "/home/user/.ssh/checkout", |
| 624 | }); |
| 625 | const result = yield* runHandoff(harness, input); |
| 626 | expect(harness.createWorktree).toHaveBeenCalledWith(expect.objectContaining({ path: null })); |
| 627 | expect(result.worktreePath).toBe("/worktrees/project/feature/elsewhere"); |
| 628 | }); |
| 629 | }); |
| 630 | |
| 631 | it.effect("releases the per-thread guard after a failed handoff", () => { |
| 632 | const harness = makeHarness({ |
| 633 | thread: { worktreePath: "/worktrees/project/existing" }, |
| 634 | }); |
| 635 | return Effect.gen(function* () { |
| 636 | const service = yield* resolveService(harness); |
| 637 | |
| 638 | const first = yield* Effect.exit( |
| 639 | service.handoff(harness.scope, { branch: "feature/guard-1" }), |
| 640 | ); |
| 641 | expectTypedFailure(first, { _tag: "WorktreeMcpFailure", code: "already_in_worktree" }); |
| 642 | const second = yield* Effect.exit( |
| 643 | service.handoff(harness.scope, { branch: "feature/guard-2" }), |
| 644 | ); |
| 645 | expectTypedFailure(second, { _tag: "WorktreeMcpFailure", code: "already_in_worktree" }); |
| 646 | }); |
| 647 | }); |
| 648 | |
| 649 | it.effect("serializes concurrent handoffs for the same thread", () => |
| 650 | Effect.gen(function* () { |
| 651 | const gate = yield* Deferred.make<void>(); |
| 652 | const harness = makeHarness({ createWorktreeGate: Deferred.await(gate) }); |
| 653 | |
| 654 | const service = yield* resolveService(harness); |
| 655 | |
| 656 | const first = yield* Effect.forkChild( |
| 657 | Effect.exit(service.handoff(harness.scope, { branch: "feature/race-1" })), |
| 658 | ); |
| 659 | yield* Effect.yieldNow; |
| 660 | |
| 661 | const second = yield* Effect.exit( |
| 662 | service.handoff(harness.scope, { branch: "feature/race-2" }), |
| 663 | ); |
| 664 | expectTypedFailure(second, { _tag: "WorktreeMcpFailure", code: "handoff_in_progress" }); |
| 665 | |
| 666 | yield* Deferred.succeed(gate, undefined); |
| 667 | const firstExit = yield* Fiber.join(first); |
| 668 | expect(Exit.isSuccess(firstExit)).toBe(true); |
| 669 | expect(harness.createWorktree).toHaveBeenCalledTimes(1); |
| 670 | }), |
| 671 | ); |
| 672 | |
| 673 | it.effect("reports a setup script defect without failing the handoff", () => { |
| 674 | const harness = makeHarness({ setupScript: "dies" }); |
| 675 | return Effect.gen(function* () { |
| 676 | const result = yield* runHandoff(harness, { branch: "feature/setup-dies" }); |
| 677 | expect(result.setupScript).toEqual({ status: "failed", detail: "setup runner defect" }); |
| 678 | expect(harness.dispatch).toHaveBeenCalled(); |
| 679 | }); |
| 680 | }); |
| 681 | }); |
| 682 | |
| 683 | describe("t3_worktree_status", () => { |
| 684 | it.effect("reports an attached thread's worktree and branch", () => { |
| 685 | const harness = makeHarness({ |
| 686 | thread: { |
| 687 | worktreePath: "/worktrees/project/existing", |
| 688 | branch: "feature/existing", |
| 689 | }, |
| 690 | projectNewWorktreesStartFromOrigin: true, |
| 691 | }); |
| 692 | return Effect.gen(function* () { |
| 693 | const result = yield* runStatus(harness); |
| 694 | expect(result).toMatchObject({ |
| 695 | attached: true, |
| 696 | worktreePath: "/worktrees/project/existing", |
| 697 | branch: "feature/existing", |
| 698 | defaultStartFromOrigin: true, |
| 699 | }); |
| 700 | }); |
| 701 | }); |
| 702 | }); |
| 703 | |
| 704 | describe("t3_worktree_list", () => { |
| 705 | const listRefs = (harness: ReturnType<typeof makeHarness>, worktreePath: string | null) => |
| 706 | Effect.gen(function* () { |
| 707 | const service = yield* WorktreeMcpService.WorktreeMcpService; |
| 708 | return yield* service.listRefs({ worktreePath, workspaceRoot }); |
| 709 | }).pipe(Effect.provide(harness.layer)); |
| 710 | |
| 711 | it.effect("lists refs from the thread's worktree, or the project root once it was removed", () => |
| 712 | Effect.gen(function* () { |
| 713 | const fs = yield* FileSystem.FileSystem; |
| 714 | const worktreePath = yield* fs.makeTempDirectoryScoped({ prefix: "worktree-list-" }); |
| 715 | const harness = makeHarness(); |
| 716 | yield* listRefs(harness, worktreePath); |
| 717 | yield* listRefs(harness, `${worktreePath}/removed`); |
| 718 | expect(harness.listRefs.mock.calls.map(([input]) => input.cwd)).toEqual([ |
| 719 | worktreePath, |
| 720 | workspaceRoot, |
| 721 | ]); |
| 722 | }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)), |
| 723 | ); |
| 724 | |
| 725 | it.effect("fails instead of falling back when the worktree cannot be checked", () => { |
| 726 | const harness = makeHarness({ existsFails: true }); |
| 727 | return Effect.gen(function* () { |
| 728 | const exit = yield* Effect.exit(listRefs(harness, "/worktrees/project/unreadable")); |
| 729 | expectTypedFailure(exit, { _tag: "PlatformError" }); |
| 730 | expect(harness.listRefs).not.toHaveBeenCalled(); |
| 731 | }); |
| 732 | }); |
| 733 | }); |