Open History to see the last commit
1import * as NodeServices from "@effect/platform-node/NodeServices";
2import { it } from "@effect/vitest";
3import {
4 ANTIGRAVITY_DEFAULT_MODEL,
5 ProviderInstanceId,
6 ProviderSetupError,
7} from "@t3tools/contracts";
8import { symlinksSupported } from "@t3tools/shared/testing/symlinks";
9import * as Deferred from "effect/Deferred";
10import * as Effect from "effect/Effect";
11import * as Exit from "effect/Exit";
12import * as Fiber from "effect/Fiber";
13import * as FileSystem from "effect/FileSystem";
14import * as Path from "effect/Path";
15import * as Queue from "effect/Queue";
16import * as Schema from "effect/Schema";
17import * as Scope from "effect/Scope";
18import * as Stream from "effect/Stream";
19import { type AcpError, AcpRequestError } from "effect-acp/errors";
20import type * as AcpSchema from "effect-acp/compat";
21import { expect } from "vite-plus/test";
22
23import type * as AcpSessionRuntime from "@t3tools/provider-acp/server/AcpSessionRuntime";
24import { removeAntigravitySessionFiles } from "../provider/acp/AntigravitySessionFiles.ts";
25
26import {
27 type AntigravityTextGenerationOptions,
28 isAntigravityTextGenerationAvailable,
29 makeAntigravityTextGeneration,
30} from "./AntigravityTextGeneration.ts";
31
32type TextRuntime = Effect.Success<ReturnType<AntigravityTextGenerationOptions["makeRuntime"]>>;
33
34const requestContext = { requestId: "test-request", method: "test" };
35const SESSION_ID = "047c62f6-607b-44db-bfbe-f83b67e9e8b1";
36const modelSelection = {
37 instanceId: ProviderInstanceId.make("antigravity-test"),
38 model: "gemini-test",
39};
40const encodeMetadata = Schema.encodeEffect(
41 Schema.fromJsonString(Schema.Struct({ cwd: Schema.String })),
42);
43
44interface PromptContext {
45 readonly emit: (
46 update: AcpSchema.SessionNotification["update"],
47 sessionId?: string,
48 ) => Effect.Effect<void, AcpError>;
49 permission: Parameters<TextRuntime["handleRequestPermission"]>[0];
50 question: Parameters<TextRuntime["handleElicitation"]>[0];
51 readFile: Parameters<TextRuntime["handleReadTextFile"]>[0];
52 createTerminal: Parameters<TextRuntime["handleCreateTerminal"]>[0];
53 extension: Parameters<TextRuntime["handleUnknownExtRequest"]>[0];
54 readonly cwd: string;
55}
56
57const makeFixture = Effect.fn("makeAntigravityTextGenerationFixture")(function* (
58 options: {
59 readonly outputs?: ReadonlyArray<string>;
60 readonly prompt?: (context: PromptContext) => Effect.Effect<AcpSchema.PromptResponse, AcpError>;
61 readonly startError?: AcpError;
62 readonly rejectAdmission?: boolean;
63 readonly sessionId?: string;
64 readonly startupSkills?: boolean;
65 } = {},
66) {
67 const fs = yield* FileSystem.FileSystem;
68 const path = yield* Path.Path;
69 const root = yield* fs.makeTempDirectoryScoped({ prefix: "t3-antigravity-text-test-" });
70 const profileDirectory = path.join(root, "profile");
71 const projectDirectory = path.join(root, "project");
72 const conversations = path.join(profileDirectory, "antigravity-acp", "conversations");
73 const nativeSessionId = options.sessionId ?? SESSION_ID;
74 const sessionBase = path.join(conversations, SESSION_ID);
75 const brainDirectory = path.join(profileDirectory, "antigravity-acp", "brain", SESSION_ID);
76 yield* fs.makeDirectory(projectDirectory, { recursive: true });
77 yield* fs.makeDirectory(conversations, { recursive: true });
78 yield* fs.writeFileString(path.join(projectDirectory, "keep.txt"), "untouched");
79 yield* fs.writeFileString(path.join(conversations, "user-session.db"), "keep native history");
80 const enteredPrompt = yield* Deferred.make<void>();
81 const state = {
82 workspaces: [] as Array<string>,
83 closed: [] as Array<string>,
84 prompts: [] as Array<Parameters<TextRuntime["prompt"]>[0]>,
85 selectedModels: [] as Array<string>,
86 selectedModes: [] as Array<string>,
87 nativeFilesAtClose: [] as Array<boolean>,
88 cancellations: 0,
89 stop: undefined as Effect.Effect<void> | undefined,
90 };
91 const outputs = [...(options.outputs ?? ['{"title":"Repair login"}'])];
92 const incoming: Omit<PromptContext, "cwd" | "emit"> = {
93 permission: () => Effect.die("No permission handler."),
94 question: () => Effect.die("No question handler."),
95 readFile: () => Effect.die("No file handler."),
96 createTerminal: () => Effect.die("No terminal handler."),
97 extension: () => Effect.die("No extension handler."),
98 };
99
100 const withProcess: AntigravityTextGenerationOptions["withProcess"] = (stop, task) =>
101 Effect.gen(function* () {
102 if (options.rejectAdmission) {
103 return yield* new ProviderSetupError({
104 instanceId: modelSelection.instanceId,
105 operation: "launch",
106 detail: "Sign in before starting Antigravity.",
107 });
108 }
109 const scope = yield* Scope.Scope;
110 const child = yield* Effect.forkIn(task, scope);
111 state.stop = Fiber.interrupt(child).pipe(Effect.andThen(stop));
112 yield* Effect.addFinalizer(() =>
113 Effect.sync(() => {
114 state.stop = undefined;
115 }),
116 );
117 return yield* Fiber.await(child).pipe(
118 Effect.flatten,
119 Effect.ensuring(Fiber.interrupt(child)),
120 );
121 });
122
123 const makeRuntime: AntigravityTextGenerationOptions["makeRuntime"] = (cwd) =>
124 Effect.gen(function* () {
125 const events = yield* Queue.unbounded<AcpSessionRuntime.AcpSessionRuntimeEvent>();
126 state.workspaces.push(cwd);
127 expect(yield* fs.readDirectory(cwd).pipe(Effect.orDie)).toEqual([]);
128 yield* Effect.addFinalizer(() =>
129 Effect.gen(function* () {
130 state.nativeFilesAtClose.push(yield* fs.exists(`${sessionBase}.db`).pipe(Effect.orDie));
131 state.closed.push(cwd);
132 }),
133 );
134 let sessionUpdate: Parameters<TextRuntime["handleSessionUpdate"]>[0] = () => Effect.void;
135
136 return {
137 start: () =>
138 Effect.gen(function* () {
139 if (options.startError) return yield* options.startError;
140 if (options.startupSkills) {
141 for (const directory of [".agents", ".gemini"]) {
142 yield* fs
143 .makeDirectory(path.join(cwd, directory, "skills"), { recursive: true })
144 .pipe(Effect.orDie);
145 }
146 }
147 yield* fs.makeDirectory(brainDirectory, { recursive: true }).pipe(Effect.orDie);
148 yield* fs.writeFileString(`${sessionBase}.db`, "helper session").pipe(Effect.orDie);
149 yield* fs.writeFileString(`${sessionBase}.db-wal`, "helper journal").pipe(Effect.orDie);
150 const metadata = yield* encodeMetadata({ cwd }).pipe(Effect.orDie);
151 yield* fs.writeFileString(`${sessionBase}.meta`, metadata).pipe(Effect.orDie);
152 yield* fs
153 .writeFileString(path.join(brainDirectory, "output.txt"), "helper artifact")
154 .pipe(Effect.orDie);
155 return {
156 sessionId: nativeSessionId,
157 initializeResult: { protocolVersion: 1 },
158 sessionSetupResult: { sessionId: nativeSessionId },
159 modelConfigId: "model",
160 };
161 }),
162 setMode: (mode) =>
163 Effect.sync(() => {
164 state.selectedModes.push(mode);
165 return {};
166 }),
167 getConfigOptions: Effect.succeed([
168 {
169 id: "model",
170 name: "Model",
171 category: "model",
172 type: "select",
173 currentValue: modelSelection.model,
174 options: [{ value: modelSelection.model, name: "Gemini test" }],
175 },
176 ]),
177 getEvents: () => Stream.fromQueue(events),
178 setModel: (model) =>
179 Effect.sync(() => {
180 state.selectedModels.push(model);
181 }),
182 setConfigOption: () => Effect.succeed({ configOptions: [] }),
183 prompt: (request) =>
184 Effect.gen(function* () {
185 state.prompts.push(request);
186 yield* Deferred.succeed(enteredPrompt, undefined);
187 const emit: PromptContext["emit"] = (update, sessionId = nativeSessionId) =>
188 sessionUpdate({ sessionId, update });
189 if (options.prompt) {
190 return yield* options.prompt({
191 emit,
192 ...incoming,
193 cwd,
194 });
195 }
196 const output = outputs.shift() ?? '{"title":"Repair login"}';
197 yield* emit({
198 sessionUpdate: "agent_thought_chunk",
199 content: { type: "text", text: "Choose concise text." },
200 });
201 yield* emit(
202 {
203 sessionUpdate: "agent_message_chunk",
204 content: { type: "text", text: "unrelated session" },
205 },
206 "another-session",
207 );
208 for (const text of [output.slice(0, 9), output.slice(9)]) {
209 yield* emit({
210 sessionUpdate: "agent_message_chunk",
211 content: { type: "text", text },
212 });
213 }
214 return { stopReason: "end_turn" };
215 }),
216 cancel: Effect.gen(function* () {
217 state.cancellations += 1;
218 const acknowledge = yield* Deferred.make<void>();
219 yield* Queue.offer(events, { _tag: "EventStreamBarrier", acknowledge });
220 yield* Deferred.await(acknowledge);
221 }),
222 handleSessionUpdate: (handler) =>
223 Effect.sync(() => {
224 sessionUpdate = handler;
225 }),
226 handleRequestPermission: (handler) =>
227 Effect.sync(() => {
228 incoming.permission = handler;
229 }),
230 handleElicitation: (handler) =>
231 Effect.sync(() => {
232 incoming.question = handler;
233 }),
234 handleReadTextFile: (handler) =>
235 Effect.sync(() => {
236 incoming.readFile = handler;
237 }),
238 handleWriteTextFile: () => Effect.void,
239 handleCreateTerminal: (handler) =>
240 Effect.sync(() => {
241 incoming.createTerminal = handler;
242 }),
243 handleTerminalOutput: () => Effect.void,
244 handleTerminalWaitForExit: () => Effect.void,
245 handleTerminalKill: () => Effect.void,
246 handleTerminalRelease: () => Effect.void,
247 handleUnknownExtRequest: (handler) =>
248 Effect.sync(() => {
249 incoming.extension = handler;
250 }),
251 } satisfies TextRuntime;
252 });
253
254 const textGeneration = yield* makeAntigravityTextGeneration({
255 profileDirectory,
256 makeRuntime,
257 withProcess,
258 });
259 const titleInput = { cwd: projectDirectory, message: "Repair Google login", modelSelection };
260 const assertCleaned = Effect.gen(function* () {
261 expect(state.closed).toEqual(state.workspaces);
262 for (const workspace of state.workspaces) {
263 expect(yield* fs.exists(workspace)).toBe(false);
264 }
265 expect(yield* fs.exists(`${sessionBase}.db`)).toBe(false);
266 expect(yield* fs.exists(`${sessionBase}.db-wal`)).toBe(false);
267 expect(yield* fs.exists(`${sessionBase}.meta`)).toBe(false);
268 expect(yield* fs.exists(brainDirectory)).toBe(false);
269 expect(yield* fs.readFileString(path.join(projectDirectory, "keep.txt"))).toBe("untouched");
270 expect(yield* fs.readFileString(path.join(conversations, "user-session.db"))).toBe(
271 "keep native history",
272 );
273 });
274 return {
275 fs,
276 path,
277 profileDirectory,
278 projectDirectory,
279 sessionBase,
280 brainDirectory,
281 state,
282 incoming,
283 enteredPrompt,
284 textGeneration,
285 titleInput,
286 assertCleaned,
287 };
288});
289
290it.layer(NodeServices.layer)("AntigravityTextGeneration", (it) => {
291 it.effect.each([false, true])(
292 "generates all helper types and cleans up with startupSkills=%s",
293 (startupSkills) =>
294 Effect.gen(function* () {
295 const fixture = yield* makeFixture({
296 startupSkills,
297 outputs: [
298 '{"subject":" Repair Google login.\\nExtra line","body":" Keep the remote callback. ","branch":"Repair Login"}',
299 '```json\n{"title":" Repair Google login\\nExtra line","body":" ## Summary\\nSupport remote callbacks. "}\n```',
300 '{"branch":" Repair Google Login "}',
301 '{"title":" \\"Repair Google login\\" "}',
302 ],
303 });
304 const common = { cwd: fixture.projectDirectory, modelSelection };
305 expect(
306 yield* fixture.textGeneration.generateCommitMessage({
307 ...common,
308 branch: "feature/login",
309 stagedSummary: "M login.ts",
310 stagedPatch: "+handleRemoteCallback()",
311 includeBranch: true,
312 }),
313 ).toEqual({
314 subject: "Repair Google login",
315 body: "Keep the remote callback.",
316 branch: "feature/repair-login",
317 });
318 expect(
319 yield* fixture.textGeneration.generatePrContent({
320 ...common,
321 baseBranch: "main",
322 headBranch: "feature/login",
323 commitSummary: "Repair login",
324 diffSummary: "M login.ts",
325 diffPatch: "+handleRemoteCallback()",
326 }),
327 ).toEqual({ title: "Repair Google login", body: "## Summary\nSupport remote callbacks." });
328 expect(
329 yield* fixture.textGeneration.generateBranchName({
330 ...common,
331 message: "Repair Google login",
332 }),
333 ).toEqual({ branch: "repair-google-login" });
334 expect(yield* fixture.textGeneration.generateThreadTitle(fixture.titleInput)).toEqual({
335 title: "Repair Google login",
336 });
337 expect(new Set(fixture.state.workspaces).size).toBe(4);
338 expect(fixture.state.workspaces).not.toContain(fixture.projectDirectory);
339 expect(fixture.state.nativeFilesAtClose).toEqual([true, true, true, true]);
340 expect(fixture.state.selectedModes).toEqual(["default", "default", "default", "default"]);
341 expect(fixture.state.selectedModels).toEqual(Array(4).fill(modelSelection.model));
342 expect(fixture.state.prompts[0]?.prompt).toEqual([
343 { type: "text", text: expect.stringContaining("+handleRemoteCallback()") },
344 ]);
345 yield* fixture.assertCleaned;
346 }).pipe(Effect.scoped),
347 );
348
349 it.effect.each(["tool_call", "tool_call_update"] as const)(
350 "aborts on %s even without a permission request",
351 (sessionUpdate) =>
352 Effect.gen(function* () {
353 const fixture = yield* makeFixture({
354 prompt: ({ emit }) =>
355 emit({ sessionUpdate, toolCallId: "tool-1", title: "Read files" }).pipe(
356 Effect.andThen(Effect.never),
357 ),
358 });
359 const error = yield* fixture.textGeneration
360 .generateThreadTitle(fixture.titleInput)
361 .pipe(Effect.flip);
362 expect(error.detail).toContain("tool work");
363 expect(fixture.state.cancellations).toBe(1);
364 yield* fixture.assertCleaned;
365 }).pipe(Effect.scoped),
366 );
367
368 it.effect("rejects native permission and choice requests instead of answering them", () =>
369 Effect.gen(function* () {
370 const fixture = yield* makeFixture({ prompt: () => Effect.never });
371 const child = yield* fixture.textGeneration
372 .generateThreadTitle(fixture.titleInput)
373 .pipe(Effect.forkChild);
374 yield* Deferred.await(fixture.enteredPrompt);
375 const reply = yield* fixture.incoming.permission(
376 {
377 sessionId: SESSION_ID,
378 toolCall: { toolCallId: "question-1", title: "Choose a title", kind: "other" },
379 options: [
380 { optionId: "first-native-choice", name: "Use this title", kind: "allow_once" },
381 { optionId: "second-native-choice", name: "Use this title", kind: "allow_once" },
382 ],
383 },
384 requestContext,
385 );
386 const error = yield* Fiber.join(child).pipe(Effect.flip);
387 expect(reply).toEqual({ outcome: { outcome: "cancelled" } });
388 expect(error.detail).toContain("permission or user input");
389 yield* fixture.assertCleaned;
390 }).pipe(Effect.scoped),
391 );
392
393 it.effect.each(["file", "terminal", "extension"] as const)(
394 "denies unexpected %s requests",
395 (kind) =>
396 Effect.gen(function* () {
397 const fixture = yield* makeFixture({ prompt: () => Effect.never });
398 const child = yield* fixture.textGeneration
399 .generateThreadTitle(fixture.titleInput)
400 .pipe(Effect.forkChild);
401 yield* Deferred.await(fixture.enteredPrompt);
402 const request =
403 kind === "file"
404 ? fixture.incoming.readFile(
405 { sessionId: SESSION_ID, path: "/not-allowed" },
406 requestContext,
407 )
408 : kind === "terminal"
409 ? fixture.incoming.createTerminal(
410 { sessionId: SESSION_ID, command: "not-allowed" },
411 requestContext,
412 )
413 : fixture.incoming.extension("_ask_user", {}, requestContext);
414 const denied = yield* request.pipe(Effect.exit);
415 expect(Exit.isFailure(denied)).toBe(true);
416 const error = yield* Fiber.join(child).pipe(Effect.flip);
417 expect(error.detail).toContain("tool or user input");
418 yield* fixture.assertCleaned;
419 }).pipe(Effect.scoped),
420 );
421
422 it.effect.each([
423 { output: " ", detail: "empty" },
424 { output: "No JSON here", detail: "invalid structured output" },
425 { output: '{"title":42}', detail: "invalid structured output" },
426 { output: "x".repeat(128_001), detail: "output limit" },
427 ])("rejects $detail output and closes the runtime", ({ output, detail }) =>
428 Effect.gen(function* () {
429 const fixture = yield* makeFixture({ outputs: [output] });
430 const error = yield* fixture.textGeneration
431 .generateThreadTitle(fixture.titleInput)
432 .pipe(Effect.flip);
433 expect(error.detail).toContain(detail);
434 yield* fixture.assertCleaned;
435 }).pipe(Effect.scoped),
436 );
437
438 it.effect("does not return partial JSON after native cancellation", () =>
439 Effect.gen(function* () {
440 const fixture = yield* makeFixture({
441 prompt: ({ emit }) =>
442 emit({
443 sessionUpdate: "agent_message_chunk",
444 content: { type: "text", text: '{"title":"Partial title"}' },
445 }).pipe(Effect.as({ stopReason: "cancelled" })),
446 });
447 const error = yield* fixture.textGeneration
448 .generateThreadTitle(fixture.titleInput)
449 .pipe(Effect.flip);
450 expect(error.detail).toContain("cancelled");
451 yield* fixture.assertCleaned;
452 }).pipe(Effect.scoped),
453 );
454
455 it.effect.each([
456 {
457 code: -32000,
458 detail: "Sign in to Antigravity in Settings before you continue.",
459 },
460 { code: -32603, detail: "Antigravity text generation failed." },
461 ])("maps ACP error $code from the prompt request to a fixed detail", ({ code, detail }) =>
462 Effect.gen(function* () {
463 const fixture = yield* makeFixture({
464 prompt: () =>
465 Effect.fail(new AcpRequestError({ code, errorMessage: "Raw provider failure text." })),
466 });
467 const error = yield* fixture.textGeneration
468 .generateThreadTitle(fixture.titleInput)
469 .pipe(Effect.flip);
470 expect(error.detail).toBe(detail);
471 expect(error.detail).not.toContain("Raw provider failure text.");
472 yield* fixture.assertCleaned;
473 }).pipe(Effect.scoped),
474 );
475
476 it.effect.each([
477 { relativePath: "unexpected.txt", kind: "file" },
478 { relativePath: ".agents/skills/unexpected.txt", kind: "file" },
479 { relativePath: ".gemini/unexpected", kind: "directory" },
480 { relativePath: ".agents/skills", kind: "file" },
481 ...(symlinksSupported ? [{ relativePath: ".gemini/skills", kind: "symlink" }] : []),
482 ])(
483 "rejects an unexpected $kind at $relativePath in its temporary workspace",
484 ({ relativePath, kind }) =>
485 Effect.gen(function* () {
486 const fs = yield* FileSystem.FileSystem;
487 const path = yield* Path.Path;
488 const target =
489 kind === "symlink"
490 ? yield* fs.makeTempDirectoryScoped({ prefix: "t3-antigravity-link-test-" })
491 : undefined;
492 const fixture = yield* makeFixture({
493 startupSkills: true,
494 prompt: ({ cwd, emit }) =>
495 Effect.gen(function* () {
496 const entry = path.join(cwd, relativePath);
497 if (yield* fs.exists(entry).pipe(Effect.orDie)) {
498 yield* fs.remove(entry, { recursive: true }).pipe(Effect.orDie);
499 }
500 yield* (
501 target !== undefined
502 ? fs.symlink(target, entry)
503 : kind === "directory"
504 ? fs.makeDirectory(entry)
505 : fs.writeFileString(entry, "unexpected")
506 ).pipe(Effect.orDie);
507 yield* emit({
508 sessionUpdate: "agent_message_chunk",
509 content: { type: "text", text: '{"title":"Ignored output"}' },
510 });
511 return { stopReason: "end_turn" };
512 }),
513 });
514 const error = yield* fixture.textGeneration
515 .generateThreadTitle(fixture.titleInput)
516 .pipe(Effect.flip);
517 expect(error.detail).toContain("wrote files");
518 if (target !== undefined) expect(yield* fs.exists(target)).toBe(true);
519 yield* fixture.assertCleaned;
520 }).pipe(Effect.scoped),
521 );
522
523 it.effect("uses the native default without sending T3's default selection as a model ID", () =>
524 Effect.gen(function* () {
525 const fixture = yield* makeFixture();
526 const result = yield* fixture.textGeneration.generateThreadTitle({
527 ...fixture.titleInput,
528 modelSelection: { ...modelSelection, model: ANTIGRAVITY_DEFAULT_MODEL },
529 });
530 expect(result).toEqual({ title: "Repair login" });
531 expect(fixture.state.selectedModels).toEqual([]);
532 yield* fixture.assertCleaned;
533 }).pipe(Effect.scoped),
534 );
535
536 it.effect.each([
537 {
538 name: "hooks.json",
539 value: '{"default":{"PreInvocation":[{"command":"do-not-run"}]}}',
540 available: false,
541 },
542 {
543 name: "mcp_config.json",
544 value: '{"mcpServers":{"server":{"command":"do-not-run"}}}',
545 available: false,
546 },
547 { name: "hooks.json", value: "invalid JSON", available: false },
548 { name: "mcp_config.json", value: "x".repeat(64_001), available: false },
549 { name: "hooks.json", value: "{}", available: true },
550 { name: "hooks.json", value: '{"hooks":{}}', available: true },
551 { name: "mcp_config.json", value: '{"mcpServers":{}}', available: true },
552 ])("checks $name before starting a helper, available=$available", ({ name, value, available }) =>
553 Effect.gen(function* () {
554 const fixture = yield* makeFixture();
555 const configDirectory = fixture.path.join(fixture.profileDirectory, "config");
556 yield* fixture.fs.makeDirectory(configDirectory, { recursive: true });
557 yield* fixture.fs.writeFileString(fixture.path.join(configDirectory, name), value);
558 expect(yield* isAntigravityTextGenerationAvailable(fixture.profileDirectory)).toBe(available);
559 const result = yield* fixture.textGeneration
560 .generateThreadTitle(fixture.titleInput)
561 .pipe(Effect.exit);
562 expect(Exit.isSuccess(result)).toBe(available);
563 expect(fixture.state.workspaces.length).toBe(available ? 1 : 0);
564 yield* fixture.assertCleaned;
565 }).pipe(Effect.scoped),
566 );
567
568 it.effect("does not launch during sign-out or before sign-in", () =>
569 Effect.gen(function* () {
570 const fixture = yield* makeFixture({ rejectAdmission: true });
571 const error = yield* fixture.textGeneration
572 .generateThreadTitle(fixture.titleInput)
573 .pipe(Effect.flip);
574 expect(error._tag).toBe("TextGenerationError");
575 expect(error.detail).toBe("Sign in before starting Antigravity.");
576 expect(fixture.state.workspaces).toEqual([]);
577 yield* fixture.assertCleaned;
578 }).pipe(Effect.scoped),
579 );
580
581 it.effect.each(["caller", "sign-out"] as const)(
582 "closes all helper resources when stopped by %s",
583 (source) =>
584 Effect.gen(function* () {
585 const fixture = yield* makeFixture({ prompt: () => Effect.never });
586 const child = yield* fixture.textGeneration
587 .generateThreadTitle(fixture.titleInput)
588 .pipe(Effect.forkChild);
589 yield* Deferred.await(fixture.enteredPrompt);
590 if (source === "caller") {
591 yield* Fiber.interrupt(child);
592 } else {
593 if (!fixture.state.stop) return yield* Effect.die("No tracked helper to stop.");
594 yield* fixture.state.stop;
595 yield* Fiber.await(child);
596 }
597 expect(fixture.state.cancellations).toBe(1);
598 yield* fixture.assertCleaned;
599 }).pipe(Effect.scoped),
600 );
601
602 it.effect("refuses unsafe native session IDs without deleting other files", () =>
603 Effect.gen(function* () {
604 const fixture = yield* makeFixture({ sessionId: "../../user-session" });
605 const error = yield* fixture.textGeneration
606 .generateThreadTitle(fixture.titleInput)
607 .pipe(Effect.flip);
608 expect(error.detail).toContain("invalid text helper session ID");
609 expect(fixture.state.prompts).toEqual([]);
610 expect(yield* fixture.fs.readFileString(`${fixture.sessionBase}.db`)).toBe("helper session");
611 expect(fixture.state.closed).toEqual(fixture.state.workspaces);
612 }).pipe(Effect.scoped),
613 );
614
615 it.effect("keeps native sessions whose metadata belongs to a different workspace", () =>
616 Effect.gen(function* () {
617 const fixture = yield* makeFixture();
618 yield* fixture.fs.writeFileString(`${fixture.sessionBase}.db`, "keep this session");
619 const metadata = yield* encodeMetadata({ cwd: fixture.projectDirectory });
620 yield* fixture.fs.writeFileString(`${fixture.sessionBase}.meta`, metadata);
621 yield* removeAntigravitySessionFiles({
622 profileDirectory: fixture.profileDirectory,
623 sessionId: SESSION_ID,
624 cwd: "different-temporary-workspace",
625 });
626 expect(yield* fixture.fs.readFileString(`${fixture.sessionBase}.db`)).toBe(
627 "keep this session",
628 );
629 expect(yield* fixture.fs.readFileString(`${fixture.sessionBase}.meta`)).toBe(metadata);
630 }).pipe(Effect.scoped),
631 );
632});
633
634it.effect("retains filesystem services supplied only during construction", () =>
635 Effect.gen(function* () {
636 const fixture = yield* makeFixture({ startupSkills: true }).pipe(
637 Effect.provide(NodeServices.layer),
638 );
639 expect(yield* fixture.textGeneration.generateThreadTitle(fixture.titleInput)).toEqual({
640 title: "Repair login",
641 });
642 yield* fixture.assertCleaned;
643 }).pipe(Effect.scoped),
644);